12288614352

Committed 12 Dec 2024 02:22AM UTC coverage: 28.15% (-0.004%) from 28.154%

Build # 12288614352

Build Type

Pull #391

github

Committed by

web-flow

Commit Message

Merge ddc3a3170 into 896d6c312

Pull Request Pull Request #391: Ensure emitted method signatures have the correct generic parameter count

Run Details

1266 of 6242 branches covered (20.28%)

Branch coverage included in aggregate %.

0 of 6 new or added lines in 3 files covered. (0.0%)

3385 of 10280 relevant lines covered (32.93%)

124823.47 hits per line

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

0.0

/Cpp2IL.Core/Utils/AsmResolver/ContextToMethodDescriptor.cs

using System.Linq;
using AsmResolver.DotNet;
using AsmResolver.DotNet.Signatures;
using Cpp2IL.Core.Model.Contexts;

namespace Cpp2IL.Core.Utils.AsmResolver;

public static class ContextToMethodDescriptor
{
    private static MethodDefinition GetMethodDefinition(this MethodAnalysisContext context)
    {
        return context.GetExtraData<MethodDefinition>("AsmResolverMethod") ?? throw new($"AsmResolver method not found in method analysis context for {context}");
    }

    private static MethodSignature ToMethodSignature(this MethodAnalysisContext context, ModuleDefinition parentModule)
    {
        var returnType = context.ReturnTypeContext.ToTypeSignature(parentModule);
        var parameters = context.Parameters.Select(p => p.ToTypeSignature(parentModule));

        return context.IsStatic
            ? MethodSignature.CreateStatic(returnType, context.GenericParameterCount, parameters)
            : MethodSignature.CreateInstance(returnType, context.GenericParameterCount, parameters);
    }

    public static IMethodDescriptor ToMethodDescriptor(this MethodAnalysisContext context, ModuleDefinition parentModule)
    {
        return context is ConcreteGenericMethodAnalysisContext concreteMethod
            ? concreteMethod.ToMethodDescriptor(parentModule)
            : parentModule.DefaultImporter.ImportMethod(context.GetMethodDefinition());
    }

    public static IMethodDescriptor ToMethodDescriptor(this ConcreteGenericMethodAnalysisContext context, ModuleDefinition parentModule)
    {
        var memberReference = new MemberReference(
            context.DeclaringType?.ToTypeSignature(parentModule).ToTypeDefOrRef(),
            context.Name,
            context.BaseMethodContext.ToMethodSignature(parentModule));

        var methodGenericParameters = context.ResolveMethodGenericParameters();
        if (methodGenericParameters.Length == 0)
        {
            return parentModule.DefaultImporter.ImportMethod(memberReference);
        }
        else
        {
            var typeSignatures = methodGenericParameters.Select(p => p.ToTypeSignature(parentModule)).ToArray();
            return parentModule.DefaultImporter.ImportMethod(memberReference.MakeGenericInstanceMethod(typeSignatures));
        }
    }
}

1	using System.Linq;
2	using AsmResolver.DotNet;
3	using AsmResolver.DotNet.Signatures;
4	using Cpp2IL.Core.Model.Contexts;
5
6	namespace Cpp2IL.Core.Utils.AsmResolver;
7
8	public static class ContextToMethodDescriptor
9	{
10	private static MethodDefinition GetMethodDefinition(this MethodAnalysisContext context)
11	{
12	return context.GetExtraData<MethodDefinition>("AsmResolverMethod") ?? throw new($"AsmResolver method not found in method analysis context for {context}");	×
13	}
14
15	private static MethodSignature ToMethodSignature(this MethodAnalysisContext context, ModuleDefinition parentModule)
16	{
17	var returnType = context.ReturnTypeContext.ToTypeSignature(parentModule);	×
18	var parameters = context.Parameters.Select(p => p.ToTypeSignature(parentModule));	×
19
20	return context.IsStatic	×
NEW 21	? MethodSignature.CreateStatic(returnType, context.GenericParameterCount, parameters)	×
NEW 22	: MethodSignature.CreateInstance(returnType, context.GenericParameterCount, parameters);	×
23	}
24
25	public static IMethodDescriptor ToMethodDescriptor(this MethodAnalysisContext context, ModuleDefinition parentModule)
26	{
27	return context is ConcreteGenericMethodAnalysisContext concreteMethod	×
28	? concreteMethod.ToMethodDescriptor(parentModule)	×
29	: parentModule.DefaultImporter.ImportMethod(context.GetMethodDefinition());	×
30	}
31
32	public static IMethodDescriptor ToMethodDescriptor(this ConcreteGenericMethodAnalysisContext context, ModuleDefinition parentModule)
33	{
34	var memberReference = new MemberReference(	×
35	context.DeclaringType?.ToTypeSignature(parentModule).ToTypeDefOrRef(),	×
36	context.Name,	×
37	context.BaseMethodContext.ToMethodSignature(parentModule));	×
38
39	var methodGenericParameters = context.ResolveMethodGenericParameters();	×
40	if (methodGenericParameters.Length == 0)	×
41	{
42	return parentModule.DefaultImporter.ImportMethod(memberReference);	×
43	}
44	else
45	{
46	var typeSignatures = methodGenericParameters.Select(p => p.ToTypeSignature(parentModule)).ToArray();	×
47	return parentModule.DefaultImporter.ImportMethod(memberReference.MakeGenericInstanceMethod(typeSignatures));	×
48	}
49	}
50	}

SamboyCoding / Cpp2IL / 12288614352

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