12074720245

Committed 28 Nov 2024 07:45PM UTC coverage: 28.371% (-0.02%) from 28.392%

Build # 12074720245

Build Type

Pull #382

github

Committed by

web-flow

Commit Message

Merge 697be1488 into 73abd20c0

Pull Request Pull Request #382: Add a plugin for outputting Windows PDB files

Run Details

1265 of 6204 branches covered (20.39%)

Branch coverage included in aggregate %.

2 of 53 new or added lines in 7 files covered. (3.77%)

3 existing lines in 3 files now uncovered.

3383 of 10179 relevant lines covered (33.24%)

126063.94 hits per line

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

32.18

/Cpp2IL.Core/Model/Contexts/ParameterAnalysisContext.cs

using System.Reflection;
using System.Text;
using Cpp2IL.Core.Utils;
using LibCpp2IL;
using LibCpp2IL.BinaryStructures;
using LibCpp2IL.Metadata;
using StableNameDotNet.Providers;

namespace Cpp2IL.Core.Model.Contexts;

public class ParameterAnalysisContext : HasCustomAttributesAndName, IParameterInfoProvider
{
    /// <summary>
    /// The backing il2cpp definition of this parameter. Can be null if the parameter is injected. 
    /// </summary>
    public Il2CppParameterDefinition? Definition { get; }

    /// <summary>
    /// The index of this parameter in the declaring method's parameter list.
    /// </summary>
    public int ParamIndex { get; }

    /// <summary>
    /// The method which this parameter belongs to. Cannot be null.
    /// </summary>
    public MethodAnalysisContext DeclaringMethod { get; }

    /// <summary>
    /// The il2cpp type of the parameter. Cannot be null.
    /// </summary>
    public virtual Il2CppType ParameterType => Definition?.RawType ?? throw new("Subclasses of ParameterAnalysisContext must provide a parameter type");

    protected override int CustomAttributeIndex => Definition?.customAttributeIndex ?? throw new("Subclasses of ParameterAnalysisContext must provide a customAttributeIndex");
    public override AssemblyAnalysisContext CustomAttributeAssembly => DeclaringMethod.DeclaringType!.DeclaringAssembly;
    public override string DefaultName => Definition?.Name ?? throw new("Subclasses of ParameterAnalysisContext must provide a default name");

    /// <summary>
    /// The human-readable display value of the parameter type.
    /// </summary>
    public string ReadableTypeName => ParameterTypeContext.FullName;

    /// <summary>
    /// The human-readable display value of the parameter, as it would appear in a c# method declaration.
    /// </summary>
    public string HumanReadableSignature => $"{ReadableTypeName} {Name}";

    /// <summary>
    /// The ParameterAttributes of this parameter.
    /// </summary>
    public virtual ParameterAttributes ParameterAttributes => (ParameterAttributes)ParameterType.Attrs;

    /// <summary>
    /// True if this parameter is passed by reference.
    /// </summary>
    public virtual bool IsRef => ParameterType.Byref == 1 || ParameterAttributes.HasFlag(ParameterAttributes.Out);

    /// <summary>
    /// The default value data for this parameter. Null if, and only if, the parameter has no default value. If it has a default value of literally null, this will be non-null and have a data index of -1.
    /// </summary>
    public Il2CppParameterDefaultValue? DefaultValue { get; }

    public virtual TypeAnalysisContext ParameterTypeContext => DeclaringMethod.DeclaringType!.DeclaringAssembly.ResolveIl2CppType(ParameterType);

    public ParameterAnalysisContext(Il2CppParameterDefinition? definition, int paramIndex, MethodAnalysisContext declaringMethod) : base(definition?.token ?? 0, declaringMethod.AppContext)
    {
        Definition = definition;
        ParamIndex = paramIndex;
        DeclaringMethod = declaringMethod;

        if (Definition != null)
        {
            InitCustomAttributeData();

            if (ParameterAttributes.HasFlag(ParameterAttributes.HasDefault))
            {
                DefaultValue = AppContext.Metadata.GetParameterDefaultValueFromIndex(declaringMethod.Definition!.parameterStart + paramIndex)!;
            }
        }
    }

    public override string ToString()
    {
        if (!AppContext.HasFinishedInitializing)
            //Cannot safely access ParameterTypeContext.Name if we haven't finished initializing as it may require doing system type lookups etc.
            return $"Parameter {Name} (ordinal {ParamIndex}) of {DeclaringMethod}";

        var result = new StringBuilder();

        if (ParameterAttributes.HasFlag(ParameterAttributes.Out))
            result.Append("out ");
        else if (ParameterAttributes.HasFlag(ParameterAttributes.In))
            result.Append("in ");
        else if (ParameterType.Byref == 1)
            result.Append("ref ");

        result.Append(CsFileUtils.GetTypeName(ParameterTypeContext.Name)).Append(' ');

        if (string.IsNullOrEmpty(ParameterName))
            result.Append("unnamed_param_").Append(ParamIndex);
        else
            result.Append(ParameterName);

        if (ParameterAttributes.HasFlag(ParameterAttributes.HasDefault))
        {
            var defaultValue = DefaultValue!.ContainedDefaultValue;
            if (defaultValue is string stringDefaultValue)
                defaultValue = $"\"{stringDefaultValue}\"";
            else if (defaultValue is bool boolDefaultValue)
                defaultValue = boolDefaultValue.ToString().ToLowerInvariant();
            else if (defaultValue is null)
                defaultValue = "null";

            result.Append(" = ").Append(defaultValue);
        }

        return result.ToString();
    }

    #region StableNameDotNet implementation

    public ITypeInfoProvider ParameterTypeInfoProvider
        => Definition!.RawType!.ThisOrElementIsGenericParam()
            ? new GenericParameterTypeInfoProviderWrapper(Definition.RawType!.GetGenericParamName())
            : TypeAnalysisContext.GetSndnProviderForType(AppContext, Definition.RawType);

    public string ParameterName => Name;

    #endregion
}

1	using System.Reflection;
2	using System.Text;
3	using Cpp2IL.Core.Utils;
4	using LibCpp2IL;
5	using LibCpp2IL.BinaryStructures;
6	using LibCpp2IL.Metadata;
7	using StableNameDotNet.Providers;
8
9	namespace Cpp2IL.Core.Model.Contexts;
10
11	public class ParameterAnalysisContext : HasCustomAttributesAndName, IParameterInfoProvider
12	{
13	/// <summary>
14	/// The backing il2cpp definition of this parameter. Can be null if the parameter is injected.
15	/// </summary>
16	public Il2CppParameterDefinition? Definition { get; }	1,219,510✔
17
18	/// <summary>
19	/// The index of this parameter in the declaring method's parameter list.
20	/// </summary>
21	public int ParamIndex { get; }	×
22
23	/// <summary>
24	/// The method which this parameter belongs to. Cannot be null.
25	/// </summary>
26	public MethodAnalysisContext DeclaringMethod { get; }	689,762✔
27
28	/// <summary>
29	/// The il2cpp type of the parameter. Cannot be null.
30	/// </summary>
31	public virtual Il2CppType ParameterType => Definition?.RawType ?? throw new("Subclasses of ParameterAnalysisContext must provide a parameter type");	597,104!
32
33	protected override int CustomAttributeIndex => Definition?.customAttributeIndex ?? throw new("Subclasses of ParameterAnalysisContext must provide a customAttributeIndex");	196,470!
34	public override AssemblyAnalysisContext CustomAttributeAssembly => DeclaringMethod.DeclaringType!.DeclaringAssembly;	381,786✔
35	public override string DefaultName => Definition?.Name ?? throw new("Subclasses of ParameterAnalysisContext must provide a default name");	68,362!
36
37	/// <summary>
38	/// The human-readable display value of the parameter type.
39	/// </summary>
NEW 40	public string ReadableTypeName => ParameterTypeContext.FullName;	×
41
42	/// <summary>
43	/// The human-readable display value of the parameter, as it would appear in a c# method declaration.
44	/// </summary>
45	public string HumanReadableSignature => $"{ReadableTypeName} {Name}";	×
46
47	/// <summary>
48	/// The ParameterAttributes of this parameter.
49	/// </summary>
50	public virtual ParameterAttributes ParameterAttributes => (ParameterAttributes)ParameterType.Attrs;	289,128✔
51
52	/// <summary>
53	/// True if this parameter is passed by reference.
54	/// </summary>
55	public virtual bool IsRef => ParameterType.Byref == 1 \|\| ParameterAttributes.HasFlag(ParameterAttributes.Out);	×
56
57	/// <summary>
58	/// The default value data for this parameter. Null if, and only if, the parameter has no default value. If it has a default value of literally null, this will be non-null and have a data index of -1.
59	/// </summary>
60	public Il2CppParameterDefaultValue? DefaultValue { get; }	×
61
62	public virtual TypeAnalysisContext ParameterTypeContext => DeclaringMethod.DeclaringType!.DeclaringAssembly.ResolveIl2CppType(ParameterType);	307,976✔
63
64	public ParameterAnalysisContext(Il2CppParameterDefinition? definition, int paramIndex, MethodAnalysisContext declaringMethod) : base(definition?.token ?? 0, declaringMethod.AppContext)	357,574✔
65	{
66	Definition = definition;	357,574✔
67	ParamIndex = paramIndex;	357,574✔
68	DeclaringMethod = declaringMethod;	357,574✔
69
70	if (Definition != null)	357,574✔
71	{
72	InitCustomAttributeData();	289,128✔
73
74	if (ParameterAttributes.HasFlag(ParameterAttributes.HasDefault))	289,128✔
75	{
76	DefaultValue = AppContext.Metadata.GetParameterDefaultValueFromIndex(declaringMethod.Definition!.parameterStart + paramIndex)!;	1,286✔
77	}
78	}
79	}	357,574✔
80
81	public override string ToString()
82	{
83	if (!AppContext.HasFinishedInitializing)	×
84	//Cannot safely access ParameterTypeContext.Name if we haven't finished initializing as it may require doing system type lookups etc.
85	return $"Parameter {Name} (ordinal {ParamIndex}) of {DeclaringMethod}";	×
86
87	var result = new StringBuilder();	×
88
89	if (ParameterAttributes.HasFlag(ParameterAttributes.Out))	×
90	result.Append("out ");	×
91	else if (ParameterAttributes.HasFlag(ParameterAttributes.In))	×
92	result.Append("in ");	×
93	else if (ParameterType.Byref == 1)	×
94	result.Append("ref ");	×
95
96	result.Append(CsFileUtils.GetTypeName(ParameterTypeContext.Name)).Append(' ');	×
97
98	if (string.IsNullOrEmpty(ParameterName))	×
99	result.Append("unnamed_param_").Append(ParamIndex);	×
100	else
101	result.Append(ParameterName);	×
102
103	if (ParameterAttributes.HasFlag(ParameterAttributes.HasDefault))	×
104	{
105	var defaultValue = DefaultValue!.ContainedDefaultValue;	×
106	if (defaultValue is string stringDefaultValue)	×
107	defaultValue = $"\"{stringDefaultValue}\"";	×
108	else if (defaultValue is bool boolDefaultValue)	×
109	defaultValue = boolDefaultValue.ToString().ToLowerInvariant();	×
110	else if (defaultValue is null)	×
111	defaultValue = "null";	×
112
113	result.Append(" = ").Append(defaultValue);	×
114	}
115
116	return result.ToString();	×
117	}
118
119	#region StableNameDotNet implementation
120
121	public ITypeInfoProvider ParameterTypeInfoProvider
122	=> Definition!.RawType!.ThisOrElementIsGenericParam()	×
123	? new GenericParameterTypeInfoProviderWrapper(Definition.RawType!.GetGenericParamName())	×
124	: TypeAnalysisContext.GetSndnProviderForType(AppContext, Definition.RawType);	×
125
126	public string ParameterName => Name;	×
127
128	#endregion
129	}

SamboyCoding / Cpp2IL / 12074720245

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