Skip to content

Commit ed7db8c

Browse files
MrMatthewLaytonMrMatthewLayton
authored
feature/type-declarations (#83)
* Added type declaration implementation and tests. This replaces the type name implementation, which has been marked deprecated. * Added missing xmldoc comments.
1 parent c297c93 commit ed7db8c

7 files changed

+918
-6
lines changed

‎Directory.Build.props

+3-3
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
<Project>
22
<PropertyGroup>
3-
<Version>9.4.0</Version>
4-
<PackageVersion>9.4.0</PackageVersion>
5-
<AssemblyVersion>9.4.0</AssemblyVersion>
3+
<Version>9.5.0</Version>
4+
<PackageVersion>9.5.0</PackageVersion>
5+
<AssemblyVersion>9.5.0</AssemblyVersion>
66
</PropertyGroup>
77
</Project>

‎OnixLabs.Core.UnitTests/Reflection/TypeExtensionTests.cs

+583
Large diffs are not rendered by default.

‎OnixLabs.Core/Extensions.Object.cs

+2-2
Original file line numberDiff line numberDiff line change
@@ -123,7 +123,7 @@ public static string ToRecordString(this object? value)
123123
StringBuilder builder = new();
124124
IEnumerable<PropertyInfo> properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
125125

126-
builder.Append(type.GetName());
126+
builder.Append(type.GetCSharpTypeDeclaration());
127127

128128
if (properties.IsEmpty())
129129
return builder.Append(ObjectEmptyBrackets).ToString();
@@ -160,7 +160,7 @@ public static string ToRecordString(this object? value)
160160
}
161161
catch
162162
{
163-
return string.Concat(type.GetName(), ObjectEmptyBrackets);
163+
return string.Concat(type.GetCSharpTypeDeclaration(), ObjectEmptyBrackets);
164164
}
165165
}
166166

‎OnixLabs.Core/Reflection/CSharpTypeDeclarationFormatter.cs

+233
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,233 @@
1+
// Copyright 2020 ONIXLabs
2+
//
3+
// Licensed under the Apache License, Version 2.0 (the "License");
4+
// you may not use this file except in compliance with the License.
5+
// You may obtain a copy of the License at
6+
//
7+
// http://www.apache.org/licenses/LICENSE-2.0
8+
//
9+
// Unless required by applicable law or agreed to in writing, software
10+
// distributed under the License is distributed on an "AS IS" BASIS,
11+
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+
// See the License for the specific language governing permissions and
13+
// limitations under the License.
14+
15+
using System;
16+
using System.Collections.Generic;
17+
using System.Text;
18+
using OnixLabs.Core.Text;
19+
20+
namespace OnixLabs.Core.Reflection;
21+
22+
/// <summary>
23+
/// Represents a formatter for C# type declarations.
24+
/// <remarks>
25+
/// There are some limitations as to what this formatter is capable of producing; for example, nullability state information
26+
/// for nullable reference types, and <see cref="ValueTuple"/> custom names are not available within a <see cref="Type"/>
27+
/// instance, and therefore cannot be produced by this type declaration formatter.
28+
/// </remarks>
29+
/// </summary>
30+
internal static class CSharpTypeDeclarationFormatter
31+
{
32+
private const char NullableTypeIdentifier = '?';
33+
private const char GenericTypeIdentifierMarker = '`';
34+
private const char GenericTypeOpenBracket = '<';
35+
private const char GenericTypeCloseBracket = '>';
36+
private const char ValueTupleOpenParenthesis = '(';
37+
private const char ValueTupleCloseParenthesis = ')';
38+
private const string TypeSeparator = ", ";
39+
private const string ValueTupleItemName = " Item";
40+
private const string TypeNullExceptionMessage = "Type must not be null.";
41+
42+
private static readonly Dictionary<Type, string> TypeAliases = new()
43+
{
44+
[typeof(byte)] = "byte",
45+
[typeof(sbyte)] = "sbyte",
46+
[typeof(short)] = "short",
47+
[typeof(ushort)] = "ushort",
48+
[typeof(int)] = "int",
49+
[typeof(uint)] = "uint",
50+
[typeof(long)] = "long",
51+
[typeof(ulong)] = "ulong",
52+
[typeof(nint)] = "nint",
53+
[typeof(nuint)] = "nuint",
54+
[typeof(float)] = "float",
55+
[typeof(double)] = "double",
56+
[typeof(decimal)] = "decimal",
57+
[typeof(object)] = "object",
58+
[typeof(bool)] = "bool",
59+
[typeof(char)] = "char",
60+
[typeof(string)] = "string",
61+
[typeof(void)] = "void"
62+
};
63+
64+
/// <summary>
65+
/// Gets the type declaration for the current <see cref="Type"/> instance.
66+
/// <remarks>
67+
/// Depending on the specified <see cref="TypeDeclarationFlags"/>, this method is capable or returning type declarations including
68+
/// simple type names, namespace qualified types names, aliased types names, nullable shorthand notation, generic arguments, and value tuples.
69+
/// </remarks>
70+
/// </summary>
71+
/// <param name="type">The current <see cref="Type"/> instance from which to obtain the type declaration.</param>
72+
/// <param name="flags">The flags that specify how the type declaration should be formatted.</param>
73+
/// <returns>Returns the type declaration for the current <see cref="Type"/> instance.</returns>
74+
public static string GetTypeDeclaration(Type type, TypeDeclarationFlags flags)
75+
{
76+
RequireNotNull(type, TypeNullExceptionMessage, nameof(type));
77+
78+
Type unwrappedType = ConditionallyUnwrapNullableType(type, flags);
79+
StringBuilder builder = new();
80+
81+
if (CanFormatValueTupleType(unwrappedType, flags))
82+
FormatValueTupleType(unwrappedType, builder, flags);
83+
84+
else if (CanFormatGenericType(unwrappedType, flags))
85+
FormatGenericType(unwrappedType, builder, flags);
86+
87+
else FormatTypeName(unwrappedType, builder, flags);
88+
89+
FormatNullableShorthandNotation(type, builder, flags);
90+
91+
return builder.ToString();
92+
}
93+
94+
/// <summary>
95+
/// Conditionally unwraps a <see cref="Nullable{T}"/> type, if the <see cref="TypeDeclarationFlags.UseNullableShorthandTypeNames"/> flag is set.
96+
/// </summary>
97+
/// <param name="type">The potential <see cref="Nullable{T}"/> type to unwrap.</param>
98+
/// <param name="flags">The flags that specify how the type declaration should be formatted.</param>
99+
/// <returns>
100+
/// Returns the underlying type, if the specified type is <see cref="Nullable{T}"/>, and the
101+
/// <see cref="TypeDeclarationFlags.UseNullableShorthandTypeNames"/> flag is set; otherwise, returns the current <see cref="Type"/>.
102+
/// </returns>
103+
private static Type ConditionallyUnwrapNullableType(Type type, TypeDeclarationFlags flags)
104+
{
105+
if ((flags & TypeDeclarationFlags.UseNullableShorthandTypeNames) is not 0)
106+
return Nullable.GetUnderlyingType(type) ?? type;
107+
108+
return type;
109+
}
110+
111+
/// <summary>
112+
/// Determines whether the specified type is a generic type, and whether the <see cref="TypeDeclarationFlags.UseGenericTypeArguments"/> flag is set.
113+
/// </summary>
114+
/// <param name="type">The type to check is potentially generic.</param>
115+
/// <param name="flags">The flags that specify how the type declaration should be formatted.</param>
116+
/// <returns>Returns true if the specified type is a generic type, and the <see cref="TypeDeclarationFlags.UseGenericTypeArguments"/> flag is set; otherwise, false.</returns>
117+
private static bool CanFormatGenericType(Type type, TypeDeclarationFlags flags)
118+
{
119+
bool useGenericTypeArguments = (flags & TypeDeclarationFlags.UseGenericTypeArguments) is not 0;
120+
return useGenericTypeArguments && type.IsGenericType;
121+
}
122+
123+
/// <summary>
124+
/// Determines whether the specified type is a multi-argument value-tuple type, and whether the
125+
/// <see cref="TypeDeclarationFlags.UseValueTupleSyntax"/> or <see cref="TypeDeclarationFlags.UseValueTupleNames"/> flag is set.
126+
/// </summary>
127+
/// <param name="type">The type to check is potentially a multi-argument value-tuple type.</param>
128+
/// <param name="flags">The flags that specify how the type declaration should be formatted.</param>
129+
/// <returns>
130+
/// Returns true if the specified type is a multi-argument value-tuple type, and whether the
131+
/// <see cref="TypeDeclarationFlags.UseValueTupleSyntax"/> or <see cref="TypeDeclarationFlags.UseValueTupleNames"/> flag is set; otherwise, false.
132+
/// </returns>
133+
private static bool CanFormatValueTupleType(Type type, TypeDeclarationFlags flags)
134+
{
135+
bool useTupleSyntax = (flags & TypeDeclarationFlags.UseValueTupleSyntax) is not 0;
136+
bool useTupleNames = (flags & TypeDeclarationFlags.UseValueTupleNames) is not 0;
137+
138+
return (useTupleSyntax || useTupleNames)
139+
&& type.Name.StartsWith(nameof(ValueTuple))
140+
&& type.GenericTypeArguments.Length > 1;
141+
}
142+
143+
/// <summary>
144+
/// Formats the specified type as a value-tuple.
145+
/// </summary>
146+
/// <param name="type">The type to format.</param>
147+
/// <param name="builder">The <see cref="StringBuilder"/> to which the type information will be appended.</param>
148+
/// <param name="flags">The flags that specify how the type declaration should be formatted.</param>
149+
private static void FormatValueTupleType(Type type, StringBuilder builder, TypeDeclarationFlags flags)
150+
{
151+
bool useTupleNames = (flags & TypeDeclarationFlags.UseValueTupleNames) is not 0;
152+
153+
builder.Append(ValueTupleOpenParenthesis);
154+
FormatTypeArguments(type.GetGenericArguments(), builder, flags, useTupleNames);
155+
builder.Append(ValueTupleCloseParenthesis);
156+
}
157+
158+
/// <summary>
159+
/// Formats the specified type as a generic type.
160+
/// </summary>
161+
/// <param name="type">The type to format.</param>
162+
/// <param name="builder">The <see cref="StringBuilder"/> to which the type information will be appended.</param>
163+
/// <param name="flags">The flags that specify how the type declaration should be formatted.</param>
164+
private static void FormatGenericType(Type type, StringBuilder builder, TypeDeclarationFlags flags)
165+
{
166+
FormatTypeName(type, builder, flags);
167+
builder.Append(GenericTypeOpenBracket);
168+
FormatTypeArguments(type.GetGenericArguments(), builder, flags, useTupleNames: false);
169+
builder.Append(GenericTypeCloseBracket);
170+
}
171+
172+
/// <summary>
173+
/// Formats the specified type as a type alias, namespace qualified name, or simple name.
174+
/// </summary>
175+
/// <param name="type">The type to format.</param>
176+
/// <param name="builder">The <see cref="StringBuilder"/> to which the type information will be appended.</param>
177+
/// <param name="flags">The flags that specify how the type declaration should be formatted.</param>
178+
private static void FormatTypeName(Type type, StringBuilder builder, TypeDeclarationFlags flags)
179+
{
180+
bool useAliasedTypeNames = (flags & TypeDeclarationFlags.UseAliasedTypeNames) is not 0;
181+
bool useNamespaceQualifiedTypeNames = (flags & TypeDeclarationFlags.UseNamespaceQualifiedTypeNames) is not 0;
182+
183+
if (useAliasedTypeNames && TypeAliases.TryGetValue(type, out string? alias))
184+
{
185+
builder.Append(alias);
186+
return;
187+
}
188+
189+
if (useNamespaceQualifiedTypeNames)
190+
{
191+
builder.Append((type.FullName ?? type.Name).SubstringBeforeFirst(GenericTypeIdentifierMarker));
192+
return;
193+
}
194+
195+
builder.Append(type.Name.SubstringBeforeFirst(GenericTypeIdentifierMarker));
196+
}
197+
198+
/// <summary>
199+
/// Formats the specified type's generic argument types.
200+
/// </summary>
201+
/// <param name="arguments">The argument types to format.</param>
202+
/// <param name="builder">The <see cref="StringBuilder"/> to which the type information will be appended.</param>
203+
/// <param name="flags">The flags that specify how the type declaration should be formatted.</param>
204+
/// <param name="useTupleNames">Specifies whether tuple names should be formatted.</param>
205+
private static void FormatTypeArguments(Type[] arguments, StringBuilder builder, TypeDeclarationFlags flags, bool useTupleNames)
206+
{
207+
for (int index = 0; index < arguments.Length; index++)
208+
{
209+
builder.Append(GetTypeDeclaration(arguments[index], flags));
210+
211+
if (useTupleNames)
212+
builder
213+
.Append(ValueTupleItemName)
214+
.Append(index + 1);
215+
216+
builder.Append(TypeSeparator);
217+
}
218+
219+
builder.TrimEnd(TypeSeparator);
220+
}
221+
222+
/// <summary>
223+
/// Formats the type using nullable shorthand notation.
224+
/// </summary>
225+
/// <param name="type">The type to format.</param>
226+
/// <param name="builder">The <see cref="StringBuilder"/> to which the type information will be appended.</param>
227+
/// <param name="flags">The flags that specify how the type declaration should be formatted.</param>
228+
private static void FormatNullableShorthandNotation(Type type, StringBuilder builder, TypeDeclarationFlags flags)
229+
{
230+
if ((flags & TypeDeclarationFlags.UseNullableShorthandTypeNames) is not 0 && Nullable.GetUnderlyingType(type) is not null)
231+
builder.Append(NullableTypeIdentifier);
232+
}
233+
}

‎OnixLabs.Core/Reflection/Extensions.Type.cs

+14
Original file line numberDiff line numberDiff line change
@@ -37,6 +37,7 @@ public static class TypeExtensions
3737
/// <param name="type">The current <see cref="Type"/> instance from which to obtain the formatted type name.</param>
3838
/// <param name="flags">The type name flags that will be used to format the type name.</param>
3939
/// <returns>Returns the formatted type name from the current <see cref="Type"/> instance.</returns>
40+
[Obsolete("This method has been replaced with GetCSharpTypeDeclaration and will be removed in version 10.0.0")]
4041
public static string GetName(this Type type, TypeNameFlags flags = default)
4142
{
4243
RequireNotNull(type, TypeNullExceptionMessage, nameof(type));
@@ -66,4 +67,17 @@ public static string GetName(this Type type, TypeNameFlags flags = default)
6667
/// <returns>Returns the simple type name from the current <see cref="Type"/> instance.</returns>
6768
private static string GetName(this Type type, bool useFullName) =>
6869
(useFullName ? type.FullName ?? type.Name : type.Name).SubstringBeforeFirst(GenericTypeIdentifierMarker);
70+
71+
/// <summary>
72+
/// Gets the type declaration for the current <see cref="Type"/> instance.
73+
/// <remarks>
74+
/// Depending on the specified <see cref="TypeDeclarationFlags"/>, this method is capable or returning type declarations including
75+
/// simple type names, namespace qualified types names, aliased types names, nullable shorthand notation, generic arguments, and value tuples.
76+
/// </remarks>
77+
/// </summary>
78+
/// <param name="type">The current <see cref="Type"/> instance from which to obtain the type declaration.</param>
79+
/// <param name="flags">The flags that specify how the type declaration should be formatted.</param>
80+
/// <returns>Returns the type declaration for the current <see cref="Type"/> instance.</returns>
81+
public static string GetCSharpTypeDeclaration(this Type type, TypeDeclarationFlags flags = default) =>
82+
CSharpTypeDeclarationFormatter.GetTypeDeclaration(type, flags);
6983
}

‎OnixLabs.Core/Reflection/TypeDeclarationFlags.cs

+82
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,82 @@
1+
// Copyright 2020 ONIXLabs
2+
//
3+
// Licensed under the Apache License, Version 2.0 (the "License");
4+
// you may not use this file except in compliance with the License.
5+
// You may obtain a copy of the License at
6+
//
7+
// http://www.apache.org/licenses/LICENSE-2.0
8+
//
9+
// Unless required by applicable law or agreed to in writing, software
10+
// distributed under the License is distributed on an "AS IS" BASIS,
11+
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+
// See the License for the specific language governing permissions and
13+
// limitations under the License.
14+
15+
using System;
16+
17+
namespace OnixLabs.Core.Reflection;
18+
19+
/// <summary>
20+
/// Specifies flags that control how a type name is formatted.
21+
/// </summary>
22+
[Flags]
23+
public enum TypeDeclarationFlags
24+
{
25+
/// <summary>
26+
/// Specifies that no type name arguments are applied.
27+
/// <remarks>Only simple CLR type names will be used, and excludes generic type arguments and tuple syntax.</remarks>
28+
/// </summary>
29+
None = default,
30+
31+
/// <summary>
32+
/// Specifies that namespace qualified CLR type names will be used, where applicable.
33+
/// <remarks>
34+
/// If the namespace qualified CLR type name is not available, then this will use the type's simple CLR type name instead.
35+
/// </remarks>
36+
/// </summary>
37+
UseNamespaceQualifiedTypeNames = 1 << 0,
38+
39+
/// <summary>
40+
/// Specifies that type alias names will be used, where applicable.
41+
/// <remarks>
42+
/// This flag supersedes the <see cref="UseNamespaceQualifiedTypeNames"/> flag, therefore if a type alias name is not available, then the namespace
43+
/// qualified CLR type name will be used if <see cref="UseNamespaceQualifiedTypeNames"/> is set; otherwise, the type's simple CLR type name will be used.
44+
/// </remarks>
45+
/// </summary>
46+
UseAliasedTypeNames = 1 << 1,
47+
48+
/// <summary>
49+
/// Specifies that <see cref="Nullable{T}"/> types will be formatted using nullable shorthand syntax.
50+
/// <remarks>
51+
/// This flag supersedes the <see cref="UseGenericTypeArguments"/> flag.
52+
/// </remarks>
53+
/// </summary>
54+
UseNullableShorthandTypeNames = 1 << 2,
55+
56+
/// <summary>
57+
/// Specifies that if a type is generic, it should be formatted with its generic type arguments.
58+
/// </summary>
59+
UseGenericTypeArguments = 1 << 3,
60+
61+
/// <summary>
62+
/// Specifies that types of <see cref="ValueTuple"/> will be formatted using tuple syntax.
63+
/// <remarks>This flag supersedes the <see cref="UseGenericTypeArguments"/> flag.</remarks>
64+
/// </summary>
65+
UseValueTupleSyntax = 1 << 4,
66+
67+
/// <summary>
68+
/// Specifies that types of <see cref="ValueTuple"/> will be formatted using tuple names, where applicable.
69+
/// <remarks>This flag supersedes the <see cref="UseValueTupleSyntax"/> and <see cref="UseGenericTypeArguments"/> flags.</remarks>
70+
/// </summary>
71+
UseValueTupleNames = 1 << 5,
72+
73+
/// <summary>
74+
/// Specifies that all type name flags are set.
75+
/// </summary>
76+
All = UseNamespaceQualifiedTypeNames
77+
| UseAliasedTypeNames
78+
| UseNullableShorthandTypeNames
79+
| UseGenericTypeArguments
80+
| UseValueTupleSyntax
81+
| UseValueTupleNames
82+
}

‎OnixLabs.Core/Reflection/TypeNameFlags.cs

+1-1
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@ namespace OnixLabs.Core.Reflection;
1919
/// <summary>
2020
/// Specifies flags that control how a type name is formatted.
2121
/// </summary>
22-
[Flags]
22+
[Flags, Obsolete("This enumeration has been replaced with TypeDeclarationFlags and will be removed in version 10.0.0")]
2323
public enum TypeNameFlags
2424
{
2525
/// <summary>

0 commit comments

Comments
 (0)