23144759400

Committed 16 Mar 2026 12:56PM UTC coverage: 35.085% (-0.06%) from 35.146%

Build # 23144759400

Build Type

push

github

Committed by

SamboyCoding

Commit Message

LastIndexOf instead of IndexOf

Coverage Stats

1910 of 6767 branches covered (28.23%)

Branch coverage included in aggregate %.

0 of 1 new or added line in 1 file covered. (0.0%)

27 existing lines in 1 file now uncovered.

4345 of 11061 relevant lines covered (39.28%)

253104.33 hits per line

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

0.0

/Cpp2IL.Core/Utils/CsFileUtils.cs

using System;
using System.Reflection;
using System.Text;
using Cpp2IL.Core.Logging;
using Cpp2IL.Core.Model.Contexts;
using LibCpp2IL;

namespace Cpp2IL.Core.Utils;

public static class CsFileUtils
{
    /// <summary>
    /// Returns the parameters of the given method as they would likely appear in a C# method signature.
    /// That is to say, joined with a comma and a space, and with each parameter expressed as its type, a space, then its name, and optionally a default value if one is set.
    /// Note this does not include the method name, the return type, or the parentheses around the parameters.
    /// </summary>
    /// <param name="method">The method to generate the parameter string for</param>
    /// <returns>A properly-formatted parameter string as described above.</returns>
    public static string GetMethodParameterString(MethodAnalysisContext method)
    {
        var sb = new StringBuilder();
        var first = true;
        foreach (var paramData in method!.Parameters!)
        {
            if (!first)
                sb.Append(", ");

            first = false;

            sb.Append(paramData); //ToString on the ParameterData will do the right thing.
        }

        return sb.ToString();
    }

    /// <summary>
    /// Returns all the keywords that would be present in the c# source file to generate this type, i.e. access modifiers, static/sealed/etc, and the type of type (class, enum, interface).
    /// Does not include the name of the type.
    /// </summary>
    /// <param name="type">The type to generate the keywords for</param>
    public static string GetKeyWordsForType(TypeAnalysisContext type)
    {
        var sb = new StringBuilder();
        var attributes = type.Definition!.Attributes;

        if (attributes.HasFlag(TypeAttributes.NestedPrivate))
            sb.Append("private ");
        else if (attributes.HasFlag(TypeAttributes.Public))
            sb.Append("public ");
        else
            sb.Append("internal "); //private top-level classes don't exist, for obvious reasons

        if (type.IsEnumType)
            sb.Append("enum ");
        else if (type.IsValueType)
            sb.Append("struct ");
        else if (attributes.HasFlag(TypeAttributes.Interface))
            sb.Append("interface ");
        else
        {
            if (attributes.HasFlag(TypeAttributes.Abstract) && attributes.HasFlag(TypeAttributes.Sealed))
                //Abstract Sealed => Static
                sb.Append("static ");
            else if (attributes.HasFlag(TypeAttributes.Abstract))
                sb.Append("abstract ");
            else if (attributes.HasFlag(TypeAttributes.Sealed))
                sb.Append("sealed ");

            sb.Append("class ");
        }

        return sb.ToString().Trim();
    }

    /// <summary>
    /// Returns all the keywords that would be present in the c# source file to generate this method, i.e. access modifiers, static/const/etc.
    /// Does not include the type of the field or its name.
    /// </summary>
    /// <param name="field">The field to generate keywords for</param>
    public static string GetKeyWordsForField(FieldAnalysisContext field)
    {
        var sb = new StringBuilder();
        var attributes = field.BackingData!.Attributes;

        if (attributes.HasFlag(FieldAttributes.Public))
            sb.Append("public ");
        else if (attributes.HasFlag(FieldAttributes.Family))
            sb.Append("protected ");
        if (attributes.HasFlag(FieldAttributes.Assembly))
            sb.Append("internal ");
        else if (attributes.HasFlag(FieldAttributes.Private))
            sb.Append("private ");

        if (attributes.HasFlag(FieldAttributes.Literal))
            sb.Append("const ");
        else
        {
            if (attributes.HasFlag(FieldAttributes.Static))
                sb.Append("static ");

            if (attributes.HasFlag(FieldAttributes.InitOnly))
                sb.Append("readonly ");
        }

        return sb.ToString().Trim();
    }

    /// <summary>
    /// Returns all the keywords that would be present in the c# source file to generate this method, i.e. access modifiers, static/abstract/etc.
    /// Does not include the return type, name, or parameters.
    /// </summary>
    /// <param name="method">The method to generate keywords for</param>
    /// <param name="skipSlotRelated">Skip slot-related modifiers like abstract, virtual, override</param>
    /// <param name="skipKeywordsInvalidForAccessors">Skip the public and static keywords, as those aren't valid for property accessors</param>
    public static string GetKeyWordsForMethod(MethodAnalysisContext method, bool skipSlotRelated = false, bool skipKeywordsInvalidForAccessors = false)
    {
        var sb = new StringBuilder();
        var attributes = method.Definition!.Attributes;

        if (!skipKeywordsInvalidForAccessors)
        {
            if (attributes.HasFlag(MethodAttributes.Public))
                sb.Append("public ");
            else if (attributes.HasFlag(MethodAttributes.Family))
                sb.Append("protected ");
        }

        if (attributes.HasFlag(MethodAttributes.Assembly))
            sb.Append("internal ");
        else if (attributes.HasFlag(MethodAttributes.Private))
            sb.Append("private ");

        if (!skipKeywordsInvalidForAccessors && attributes.HasFlag(MethodAttributes.Static))
            sb.Append("static ");

        if (method.DeclaringType!.Definition!.Attributes.HasFlag(TypeAttributes.Interface) || skipSlotRelated)
        {
            //Deliberate no-op to avoid unnecessarily marking interface methods as abstract
        }
        else if (attributes.HasFlag(MethodAttributes.Abstract))
            sb.Append("abstract ");
        else if (attributes.HasFlag(MethodAttributes.NewSlot))
            sb.Append("override ");
        else if (attributes.HasFlag(MethodAttributes.Virtual))
            sb.Append("virtual ");


        return sb.ToString().Trim();
    }

    /// <summary>
    /// Returns all the keywords that would be present in the c# source file to generate this event, i.e. access modifiers, static/abstract/etc.
    /// Does not include the event type or name
    /// </summary>
    /// <param name="evt">The event to generate keywords for</param>
    public static string GetKeyWordsForEvent(EventAnalysisContext evt)
    {
        var sb = new StringBuilder();

        var addAttrs = evt.Adder?.Attributes ?? 0;
        var removeAttrs = evt.Remover?.Attributes ?? 0;
        var raiseAttrs = evt.Invoker?.Attributes ?? 0;

        var all = addAttrs | removeAttrs | raiseAttrs;

        //Accessibility must be that of the most accessible method
        if (addAttrs.HasFlag(MethodAttributes.Public) || removeAttrs.HasFlag(MethodAttributes.Public) || raiseAttrs.HasFlag(MethodAttributes.Public))
            sb.Append("public ");
        else if (all.HasFlag(MethodAttributes.Family)) //Family is only one bit so we can use the OR'd attributes
            sb.Append("protected ");
        if (addAttrs.HasFlag(MethodAttributes.Assembly) || removeAttrs.HasFlag(MethodAttributes.Assembly) || raiseAttrs.HasFlag(MethodAttributes.Assembly))
            sb.Append("internal ");
        else if (all.HasFlag(MethodAttributes.Private))
            sb.Append("private ");

        if (all.HasFlag(MethodAttributes.Static))
            sb.Append("static ");

        if (evt.DeclaringType!.Definition!.Attributes.HasFlag(TypeAttributes.Interface))
        {
            //Deliberate no-op to avoid unnecessarily marking interface methods as abstract
        }
        else if (all.HasFlag(MethodAttributes.Abstract))
            sb.Append("abstract ");
        else if (all.HasFlag(MethodAttributes.NewSlot))
            sb.Append("override ");
        else if (all.HasFlag(MethodAttributes.Virtual))
            sb.Append("virtual ");

        sb.Append("event ");

        return sb.ToString().Trim();
    }

    /// <summary>
    /// Returns all the keywords that would be present in the c# source file to generate this event, i.e. access modifiers, static/abstract/etc.
    /// Does not include the event type or name
    /// </summary>
    /// <param name="prop">The event to generate keywords for</param>
    public static string GetKeyWordsForProperty(PropertyAnalysisContext prop)
    {
        var sb = new StringBuilder();

        var getterAttributes = prop.Getter?.Attributes ?? 0;
        var setterAttributes = prop.Setter?.Attributes ?? 0;

        var all = getterAttributes | setterAttributes;

        //Accessibility must be that of the most accessible method
        if (getterAttributes.HasFlag(MethodAttributes.Public) || setterAttributes.HasFlag(MethodAttributes.Public))
            sb.Append("public ");
        else if (all.HasFlag(MethodAttributes.Family)) //Family is only one bit so we can use the OR'd attributes
            sb.Append("protected ");
        if (getterAttributes.HasFlag(MethodAttributes.Assembly) || setterAttributes.HasFlag(MethodAttributes.Assembly))
            sb.Append("internal ");
        else if (all.HasFlag(MethodAttributes.Private))
            sb.Append("private ");

        if (all.HasFlag(MethodAttributes.Static))
            sb.Append("static ");

        if (prop.DeclaringType!.Definition!.Attributes.HasFlag(TypeAttributes.Interface))
        {
            //Deliberate no-op to avoid unnecessarily marking interface methods as abstract
        }
        else if (all.HasFlag(MethodAttributes.Abstract))
            sb.Append("abstract ");
        else if (all.HasFlag(MethodAttributes.NewSlot))
            sb.Append("override ");
        else if (all.HasFlag(MethodAttributes.Virtual))
            sb.Append("virtual ");

        return sb.ToString().Trim();
    }

    /// <summary>
    /// Returns all the custom attributes for the given entity, as they would appear in a C# source file (i.e. properly wrapped in square brackets, with params if known)
    /// </summary>
    /// <param name="context">The entity to generate custom attribute strings for</param>
    /// <param name="indentCount">The number of tab characters to emit at the start of each line</param>
    /// <param name="analyze">True to call <see cref="HasCustomAttributes.AnalyzeCustomAttributeData"/> before generating.</param>
    /// <param name="includeIncomplete">True to emit custom attributes even if they have required parameters that aren't known</param>
    public static string GetCustomAttributeStrings(HasCustomAttributes context, int indentCount, bool analyze = true, bool includeIncomplete = true)
    {
        var sb = new StringBuilder();

        if (analyze)
            context.AnalyzeCustomAttributeData();

        //Sort alphabetically by type name
        context.CustomAttributes!.SortByExtractedKey(a => a.Constructor.DeclaringType!.Name);

        foreach (var analyzedCustomAttribute in context.CustomAttributes!)
        {
            if (!includeIncomplete && !analyzedCustomAttribute.IsSuitableForEmission)
                continue;

            if (indentCount > 0)
                sb.Append('\t', indentCount);

            try
            {
                sb.AppendLine(analyzedCustomAttribute.ToString());
            }
            catch (Exception e)
            {
                Logger.WarnNewline("Exception printing/formatting custom attribute: " + e, "C# Generator");
                sb.Append("/*Cpp2IL: Exception outputting custom attribute of type ").Append(analyzedCustomAttribute.Constructor.DeclaringType?.Name ?? "<unknown type?>").AppendLine("*/");
            }
        }

        return sb.ToString();
    }

    /// <summary>
    /// Returns the name of the given type, as it would appear in a C# source file.
    /// This mainly involves stripping the backtick section from generic type names, and replacing certain system types with their primitive name.
    /// </summary>
    /// <param name="type"></param>
    public static string GetTypeName(TypeAnalysisContext type)
    {
        if (type is WrappedTypeAnalysisContext wrapped)
        {
            var elementTypeName = GetTypeName(wrapped.ElementType);
            switch (wrapped)
            {
                case ArrayTypeAnalysisContext arrayType:
                    {
                        return arrayType.Rank switch
                        {
                            1 => elementTypeName + "[]",
                            2 => elementTypeName + "[,]",
                            3 => elementTypeName + "[,,]",
                            _ => elementTypeName + "[" + new string(',', arrayType.Rank - 1) + "]"
                        };
                    }
                case SzArrayTypeAnalysisContext:
                    return elementTypeName + "[]";
                case PointerTypeAnalysisContext:
                    return elementTypeName + "*";
                case ByRefTypeAnalysisContext:
                    return elementTypeName; //Remove trailing & for ref params
                default:
                    return elementTypeName;
            }
        }

        if (type is GenericInstanceTypeAnalysisContext genericInstanceType)
        {
            var genericTypeName = GetTypeName(genericInstanceType.GenericType);
            var backTickIndex = genericTypeName.LastIndexOf('`');
            return backTickIndex > 0 ? genericTypeName[..backTickIndex] : genericTypeName;
        }

        if (type.Namespace is "System")
        {
            return type.Name switch
            {
                "Void" => "void",
                "Boolean" => "bool",
                "Byte" => "byte",
                "SByte" => "sbyte",
                "Char" => "char",
                "Decimal" => "decimal",
                "Single" => "float",
                "Double" => "double",
                "Int32" => "int",
                "UInt32" => "uint",
                "Int64" => "long",
                "UInt64" => "ulong",
                "Int16" => "short",
                "UInt16" => "ushort",
                "String" => "string",
                "Object" => "object",
                _ => type.Name,
            };
        }
        else
        {
            return type.Name;
        }
    }

    /// <summary>
    /// Appends inheritance data (base class and interfaces) for the given type to the given string builder.
    /// If the base class is System.Object, System.ValueType, or System.Enum, it will be ignored
    /// </summary>
    /// <param name="type"></param>
    /// <param name="sb"></param>
    public static void AppendInheritanceInfo(TypeAnalysisContext type, StringBuilder sb)
    {
        var baseType = type.BaseType;
        var needsBaseClass = baseType is { FullName: not "System.Object" and not "System.ValueType" and not "System.Enum" };
        if (needsBaseClass)
            sb.Append(" : ").Append(GetTypeName(baseType!));

        //Interfaces
        if (type.InterfaceContexts.Count <= 0)
            return;

        if (!needsBaseClass)
            sb.Append(" : ");

        var addComma = needsBaseClass;
        foreach (var iface in type.InterfaceContexts)
        {
            if (addComma)
                sb.Append(", ");

            addComma = true;

            sb.Append(GetTypeName(iface));
        }
    }
}

1	using System;
2	using System.Reflection;
3	using System.Text;
4	using Cpp2IL.Core.Logging;
5	using Cpp2IL.Core.Model.Contexts;
6	using LibCpp2IL;
7
8	namespace Cpp2IL.Core.Utils;
9
10	public static class CsFileUtils
11	{
12	/// <summary>
13	/// Returns the parameters of the given method as they would likely appear in a C# method signature.
14	/// That is to say, joined with a comma and a space, and with each parameter expressed as its type, a space, then its name, and optionally a default value if one is set.
15	/// Note this does not include the method name, the return type, or the parentheses around the parameters.
16	/// </summary>
17	/// <param name="method">The method to generate the parameter string for</param>
18	/// <returns>A properly-formatted parameter string as described above.</returns>
19	public static string GetMethodParameterString(MethodAnalysisContext method)
20	{
21	var sb = new StringBuilder();	×
22	var first = true;	×
23	foreach (var paramData in method!.Parameters!)	×
24	{
25	if (!first)	×
26	sb.Append(", ");	×
27
28	first = false;	×
29
30	sb.Append(paramData); //ToString on the ParameterData will do the right thing.	×
31	}
32
33	return sb.ToString();	×
34	}
35
36	/// <summary>
37	/// Returns all the keywords that would be present in the c# source file to generate this type, i.e. access modifiers, static/sealed/etc, and the type of type (class, enum, interface).
38	/// Does not include the name of the type.
39	/// </summary>
40	/// <param name="type">The type to generate the keywords for</param>
41	public static string GetKeyWordsForType(TypeAnalysisContext type)
42	{
43	var sb = new StringBuilder();	×
44	var attributes = type.Definition!.Attributes;	×
45
46	if (attributes.HasFlag(TypeAttributes.NestedPrivate))	×
47	sb.Append("private ");	×
48	else if (attributes.HasFlag(TypeAttributes.Public))	×
49	sb.Append("public ");	×
50	else
51	sb.Append("internal "); //private top-level classes don't exist, for obvious reasons	×
52
53	if (type.IsEnumType)	×
54	sb.Append("enum ");	×
55	else if (type.IsValueType)	×
56	sb.Append("struct ");	×
57	else if (attributes.HasFlag(TypeAttributes.Interface))	×
58	sb.Append("interface ");	×
59	else
60	{
61	if (attributes.HasFlag(TypeAttributes.Abstract) && attributes.HasFlag(TypeAttributes.Sealed))	×
62	//Abstract Sealed => Static
63	sb.Append("static ");	×
64	else if (attributes.HasFlag(TypeAttributes.Abstract))	×
65	sb.Append("abstract ");	×
66	else if (attributes.HasFlag(TypeAttributes.Sealed))	×
67	sb.Append("sealed ");	×
68
69	sb.Append("class ");	×
70	}
71
72	return sb.ToString().Trim();	×
73	}
74
75	/// <summary>
76	/// Returns all the keywords that would be present in the c# source file to generate this method, i.e. access modifiers, static/const/etc.
77	/// Does not include the type of the field or its name.
78	/// </summary>
79	/// <param name="field">The field to generate keywords for</param>
80	public static string GetKeyWordsForField(FieldAnalysisContext field)
81	{
82	var sb = new StringBuilder();	×
83	var attributes = field.BackingData!.Attributes;	×
84
85	if (attributes.HasFlag(FieldAttributes.Public))	×
86	sb.Append("public ");	×
87	else if (attributes.HasFlag(FieldAttributes.Family))	×
88	sb.Append("protected ");	×
89	if (attributes.HasFlag(FieldAttributes.Assembly))	×
90	sb.Append("internal ");	×
91	else if (attributes.HasFlag(FieldAttributes.Private))	×
92	sb.Append("private ");	×
93
94	if (attributes.HasFlag(FieldAttributes.Literal))	×
95	sb.Append("const ");	×
96	else
97	{
98	if (attributes.HasFlag(FieldAttributes.Static))	×
99	sb.Append("static ");	×
100
101	if (attributes.HasFlag(FieldAttributes.InitOnly))	×
102	sb.Append("readonly ");	×
103	}
104
105	return sb.ToString().Trim();	×
106	}
107
108	/// <summary>
109	/// Returns all the keywords that would be present in the c# source file to generate this method, i.e. access modifiers, static/abstract/etc.
110	/// Does not include the return type, name, or parameters.
111	/// </summary>
112	/// <param name="method">The method to generate keywords for</param>
113	/// <param name="skipSlotRelated">Skip slot-related modifiers like abstract, virtual, override</param>
114	/// <param name="skipKeywordsInvalidForAccessors">Skip the public and static keywords, as those aren't valid for property accessors</param>
115	public static string GetKeyWordsForMethod(MethodAnalysisContext method, bool skipSlotRelated = false, bool skipKeywordsInvalidForAccessors = false)
116	{
117	var sb = new StringBuilder();	×
118	var attributes = method.Definition!.Attributes;	×
119
120	if (!skipKeywordsInvalidForAccessors)	×
121	{
122	if (attributes.HasFlag(MethodAttributes.Public))	×
123	sb.Append("public ");	×
124	else if (attributes.HasFlag(MethodAttributes.Family))	×
125	sb.Append("protected ");	×
126	}
127
128	if (attributes.HasFlag(MethodAttributes.Assembly))	×
129	sb.Append("internal ");	×
130	else if (attributes.HasFlag(MethodAttributes.Private))	×
131	sb.Append("private ");	×
132
133	if (!skipKeywordsInvalidForAccessors && attributes.HasFlag(MethodAttributes.Static))	×
134	sb.Append("static ");	×
135
136	if (method.DeclaringType!.Definition!.Attributes.HasFlag(TypeAttributes.Interface) \|\| skipSlotRelated)	×
137	{
138	//Deliberate no-op to avoid unnecessarily marking interface methods as abstract
139	}
140	else if (attributes.HasFlag(MethodAttributes.Abstract))	×
141	sb.Append("abstract ");	×
142	else if (attributes.HasFlag(MethodAttributes.NewSlot))	×
143	sb.Append("override ");	×
144	else if (attributes.HasFlag(MethodAttributes.Virtual))	×
145	sb.Append("virtual ");	×
146
147
148	return sb.ToString().Trim();	×
149	}
150
151	/// <summary>
152	/// Returns all the keywords that would be present in the c# source file to generate this event, i.e. access modifiers, static/abstract/etc.
153	/// Does not include the event type or name
154	/// </summary>
155	/// <param name="evt">The event to generate keywords for</param>
156	public static string GetKeyWordsForEvent(EventAnalysisContext evt)
157	{
158	var sb = new StringBuilder();	×
159
160	var addAttrs = evt.Adder?.Attributes ?? 0;	×
161	var removeAttrs = evt.Remover?.Attributes ?? 0;	×
162	var raiseAttrs = evt.Invoker?.Attributes ?? 0;	×
163
164	var all = addAttrs \| removeAttrs \| raiseAttrs;	×
165
166	//Accessibility must be that of the most accessible method
167	if (addAttrs.HasFlag(MethodAttributes.Public) \|\| removeAttrs.HasFlag(MethodAttributes.Public) \|\| raiseAttrs.HasFlag(MethodAttributes.Public))	×
168	sb.Append("public ");	×
169	else if (all.HasFlag(MethodAttributes.Family)) //Family is only one bit so we can use the OR'd attributes	×
170	sb.Append("protected ");	×
171	if (addAttrs.HasFlag(MethodAttributes.Assembly) \|\| removeAttrs.HasFlag(MethodAttributes.Assembly) \|\| raiseAttrs.HasFlag(MethodAttributes.Assembly))	×
172	sb.Append("internal ");	×
173	else if (all.HasFlag(MethodAttributes.Private))	×
174	sb.Append("private ");	×
175
176	if (all.HasFlag(MethodAttributes.Static))	×
177	sb.Append("static ");	×
178
179	if (evt.DeclaringType!.Definition!.Attributes.HasFlag(TypeAttributes.Interface))	×
180	{
181	//Deliberate no-op to avoid unnecessarily marking interface methods as abstract
182	}
183	else if (all.HasFlag(MethodAttributes.Abstract))	×
184	sb.Append("abstract ");	×
185	else if (all.HasFlag(MethodAttributes.NewSlot))	×
186	sb.Append("override ");	×
187	else if (all.HasFlag(MethodAttributes.Virtual))	×
188	sb.Append("virtual ");	×
189
190	sb.Append("event ");	×
191
192	return sb.ToString().Trim();	×
193	}
194
195	/// <summary>
196	/// Returns all the keywords that would be present in the c# source file to generate this event, i.e. access modifiers, static/abstract/etc.
197	/// Does not include the event type or name
198	/// </summary>
199	/// <param name="prop">The event to generate keywords for</param>
200	public static string GetKeyWordsForProperty(PropertyAnalysisContext prop)
201	{
202	var sb = new StringBuilder();	×
203
204	var getterAttributes = prop.Getter?.Attributes ?? 0;	×
205	var setterAttributes = prop.Setter?.Attributes ?? 0;	×
206
207	var all = getterAttributes \| setterAttributes;	×
208
209	//Accessibility must be that of the most accessible method
210	if (getterAttributes.HasFlag(MethodAttributes.Public) \|\| setterAttributes.HasFlag(MethodAttributes.Public))	×
211	sb.Append("public ");	×
212	else if (all.HasFlag(MethodAttributes.Family)) //Family is only one bit so we can use the OR'd attributes	×
213	sb.Append("protected ");	×
214	if (getterAttributes.HasFlag(MethodAttributes.Assembly) \|\| setterAttributes.HasFlag(MethodAttributes.Assembly))	×
215	sb.Append("internal ");	×
216	else if (all.HasFlag(MethodAttributes.Private))	×
217	sb.Append("private ");	×
218
219	if (all.HasFlag(MethodAttributes.Static))	×
220	sb.Append("static ");	×
221
222	if (prop.DeclaringType!.Definition!.Attributes.HasFlag(TypeAttributes.Interface))	×
223	{
224	//Deliberate no-op to avoid unnecessarily marking interface methods as abstract
225	}
226	else if (all.HasFlag(MethodAttributes.Abstract))	×
227	sb.Append("abstract ");	×
228	else if (all.HasFlag(MethodAttributes.NewSlot))	×
229	sb.Append("override ");	×
230	else if (all.HasFlag(MethodAttributes.Virtual))	×
231	sb.Append("virtual ");	×
232
233	return sb.ToString().Trim();	×
234	}
235
236	/// <summary>
237	/// Returns all the custom attributes for the given entity, as they would appear in a C# source file (i.e. properly wrapped in square brackets, with params if known)
238	/// </summary>
239	/// <param name="context">The entity to generate custom attribute strings for</param>
240	/// <param name="indentCount">The number of tab characters to emit at the start of each line</param>
241	/// <param name="analyze">True to call <see cref="HasCustomAttributes.AnalyzeCustomAttributeData"/> before generating.</param>
242	/// <param name="includeIncomplete">True to emit custom attributes even if they have required parameters that aren't known</param>
243	public static string GetCustomAttributeStrings(HasCustomAttributes context, int indentCount, bool analyze = true, bool includeIncomplete = true)
244	{
245	var sb = new StringBuilder();	×
246
247	if (analyze)	×
248	context.AnalyzeCustomAttributeData();	×
249
250	//Sort alphabetically by type name
251	context.CustomAttributes!.SortByExtractedKey(a => a.Constructor.DeclaringType!.Name);	×
252
253	foreach (var analyzedCustomAttribute in context.CustomAttributes!)	×
254	{
255	if (!includeIncomplete && !analyzedCustomAttribute.IsSuitableForEmission)	×
256	continue;
257
258	if (indentCount > 0)	×
259	sb.Append('\t', indentCount);	×
260
261	try
262	{
263	sb.AppendLine(analyzedCustomAttribute.ToString());	×
264	}	×
265	catch (Exception e)	×
266	{
267	Logger.WarnNewline("Exception printing/formatting custom attribute: " + e, "C# Generator");	×
268	sb.Append("/Cpp2IL: Exception outputting custom attribute of type ").Append(analyzedCustomAttribute.Constructor.DeclaringType?.Name ?? "<unknown type?>").AppendLine("/");	×
269	}	×
270	}
271
272	return sb.ToString();	×
273	}
274
275	/// <summary>
276	/// Returns the name of the given type, as it would appear in a C# source file.
277	/// This mainly involves stripping the backtick section from generic type names, and replacing certain system types with their primitive name.
278	/// </summary>
279	/// <param name="type"></param>
280	public static string GetTypeName(TypeAnalysisContext type)
281	{
282	if (type is WrappedTypeAnalysisContext wrapped)	×
283	{
284	var elementTypeName = GetTypeName(wrapped.ElementType);	×
285	switch (wrapped)
286	{
287	case ArrayTypeAnalysisContext arrayType:
288	{
289	return arrayType.Rank switch	×
290	{	×
291	1 => elementTypeName + "[]",	×
292	2 => elementTypeName + "[,]",	×
293	3 => elementTypeName + "[,,]",	×
294	_ => elementTypeName + "[" + new string(',', arrayType.Rank - 1) + "]"	×
295	};	×
296	}
297	case SzArrayTypeAnalysisContext:
298	return elementTypeName + "[]";	×
299	case PointerTypeAnalysisContext:
300	return elementTypeName + "*";	×
301	case ByRefTypeAnalysisContext:
302	return elementTypeName; //Remove trailing & for ref params	×
303	default:
304	return elementTypeName;	×
305	}
306	}
307
308	if (type is GenericInstanceTypeAnalysisContext genericInstanceType)	×
309	{
UNCOV 310	var genericTypeName = GetTypeName(genericInstanceType.GenericType);	×
NEW 311	var backTickIndex = genericTypeName.LastIndexOf('`');	×
UNCOV 312	return backTickIndex > 0 ? genericTypeName[..backTickIndex] : genericTypeName;	×
313	}
314
UNCOV 315	if (type.Namespace is "System")	×
316	{
UNCOV 317	return type.Name switch	×
UNCOV 318	{	×
319	"Void" => "void",	×
320	"Boolean" => "bool",	×
321	"Byte" => "byte",	×
322	"SByte" => "sbyte",	×
UNCOV 323	"Char" => "char",	×
UNCOV 324	"Decimal" => "decimal",	×
325	"Single" => "float",	×
326	"Double" => "double",	×
UNCOV 327	"Int32" => "int",	×
328	"UInt32" => "uint",	×
329	"Int64" => "long",	×
UNCOV 330	"UInt64" => "ulong",	×
331	"Int16" => "short",	×
332	"UInt16" => "ushort",	×
UNCOV 333	"String" => "string",	×
334	"Object" => "object",	×
335	_ => type.Name,	×
UNCOV 336	};	×
337	}
338	else
339	{
UNCOV 340	return type.Name;	×
341	}
342	}
343
344	/// <summary>
345	/// Appends inheritance data (base class and interfaces) for the given type to the given string builder.
346	/// If the base class is System.Object, System.ValueType, or System.Enum, it will be ignored
347	/// </summary>
348	/// <param name="type"></param>
349	/// <param name="sb"></param>
350	public static void AppendInheritanceInfo(TypeAnalysisContext type, StringBuilder sb)
351	{
UNCOV 352	var baseType = type.BaseType;	×
UNCOV 353	var needsBaseClass = baseType is { FullName: not "System.Object" and not "System.ValueType" and not "System.Enum" };	×
UNCOV 354	if (needsBaseClass)	×
UNCOV 355	sb.Append(" : ").Append(GetTypeName(baseType!));	×
356
357	//Interfaces
UNCOV 358	if (type.InterfaceContexts.Count <= 0)	×
UNCOV 359	return;	×
360
UNCOV 361	if (!needsBaseClass)	×
UNCOV 362	sb.Append(" : ");	×
363
UNCOV 364	var addComma = needsBaseClass;	×
UNCOV 365	foreach (var iface in type.InterfaceContexts)	×
366	{
UNCOV 367	if (addComma)	×
UNCOV 368	sb.Append(", ");	×
369
UNCOV 370	addComma = true;	×
371
UNCOV 372	sb.Append(GetTypeName(iface));	×
373	}
UNCOV 374	}	×
375	}

SamboyCoding / Cpp2IL / 23144759400

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