private static void WriteModifiersToTranslation(Type type, TranslationBuffer buffer)
{
WriteAccessibilityToTranslation(type, buffer);
if (type.IsInterface())
{
buffer.WriteToTranslation("interface ");
return;
}
if (type.IsValueType())
{
buffer.WriteToTranslation("struct ");
return;
}
if (type.IsAbstract())
{
buffer.WriteToTranslation(type.IsSealed() ? "static " : "abstract ");
}
else if (type.IsSealed())
{
buffer.WriteToTranslation("sealed ");
}
buffer.WriteToTranslation("class ");
}
public void WriteTo(TranslationBuffer buffer)
{
_initializerTranslations.IsLongTranslation = _parent.IsLongTranslation;
buffer.WriteToTranslation(_memberName);
buffer.WriteToTranslation(" =");
_initializerTranslations.WriteTo(buffer);
}
private static void WriteTypeNamespaceIfRequired(
this TranslationBuffer buffer,
Type type,
TranslationSettings settings)
{
if (!settings.FullyQualifyTypeNames || (type.Namespace == null))
{
return;
}
buffer.WriteToTranslation(type.Namespace);
buffer.WriteToTranslation('.');
}
private static void WriteGenericTypeName(
this TranslationBuffer buffer,
Type type,
int numberOfParameters,
IList <Type> typeArguments,
TranslationSettings settings)
{
var isAnonType =
type.Name.StartsWith('<') &&
(type.Name.IndexOf("AnonymousType", StringComparison.Ordinal)) != -1;
if (isAnonType && (settings.AnonymousTypeNameFactory != null))
{
buffer.WriteToTranslation(settings.AnonymousTypeNameFactory.Invoke(type));
return;
}
string typeName;
if (isAnonType)
{
typeName = "AnonymousType";
}
else
{
var parameterCountIndex = type.Name.IndexOf("`" + numberOfParameters, StringComparison.Ordinal);
typeName = type.Name.Substring(0, parameterCountIndex);
}
buffer.WriteToTranslation(typeName);
buffer.WriteToTranslation('<');
for (var i = 0; ;)
{
var typeArgument = typeArguments[i++];
buffer.WriteFriendlyName(typeArgument, settings);
if (i == typeArguments.Count)
{
break;
}
buffer.WriteToTranslation(", ");
}
buffer.WriteToTranslation('>');
}
private static void WriteAccessibilityToTranslation(Type type, TranslationBuffer buffer)
{
if (type.IsPublic())
{
buffer.WriteToTranslation("public ");
return;
}
if (!type.IsNested)
{
buffer.WriteToTranslation("internal ");
return;
}
#if NETSTANDARD
var typeInfo = type.GetTypeInfo();
if (typeInfo.IsNestedPublic)
#else
if (type.IsNestedPublic)
#endif
{
buffer.WriteToTranslation("public ");
return;
}
#if NETSTANDARD
if (typeInfo.IsNestedAssembly)
#else
if (type.IsNestedAssembly)
#endif
{
buffer.WriteToTranslation("internal ");
return;
}
#if NETSTANDARD
if (typeInfo.IsNestedAssembly)
#else
if (type.IsNestedFamORAssem)
#endif
{
buffer.WriteToTranslation("protected internal ");
return;
}
#if NETSTANDARD
if (typeInfo.IsNestedAssembly)
#else
if (type.IsNestedFamily)
#endif
{
buffer.WriteToTranslation("protected ");
return;
}
#if NETSTANDARD
if (typeInfo.IsNestedPrivate)
#else
if (type.IsNestedPrivate)
#endif
{
buffer.WriteToTranslation("private ");
}
}
protected void WriteOpeningCheckedIfNecessary(TranslationBuffer buffer, out bool isMultiStatementChecked)
{
if (IsCheckedOperation == false)
{
isMultiStatementChecked = false;
return;
}
buffer.WriteToTranslation("checked");
isMultiStatementChecked = IsMultiStatement();
if (isMultiStatementChecked)
{
buffer.WriteOpeningBraceToTranslation();
return;
}
buffer.WriteToTranslation(_openingSymbol);
}
public void WriteTo(TranslationBuffer buffer)
{
buffer.WriteToTranslation("{ ");
var argumentCount = _translations.Count;
for (var i = 0; ;)
{
_translations[i].WriteTo(buffer);
if (++i == argumentCount)
{
break;
}
buffer.WriteToTranslation(", ");
}
buffer.WriteToTranslation(" }");
}
/// <summary>
/// Translates the given <paramref name="method"/> into a readable string.
/// </summary>
/// <param name="method">The MethodInfo to translate.</param>
/// <returns>A readable string version of the given <paramref name="method"/>.</returns>
public static string Translate(MethodInfo method)
{
if (method == null)
{
return("[Method not found]");
}
var buffer = new TranslationBuffer(method.ToString().Length);
WriteModifiersToTranslation(method, buffer);
var isProperty = method.IsPropertyGetterOrSetterCall(out var property);
buffer.WriteFriendlyName(isProperty ? property.PropertyType : method.ReturnType);
buffer.WriteSpaceToTranslation();
if (method.DeclaringType != null)
{
buffer.WriteFriendlyName(method.DeclaringType);
buffer.WriteToTranslation('.');
}
if (isProperty)
{
buffer.WriteToTranslation(property.Name);
buffer.WriteToTranslation((method.ReturnType != typeof(void)) ? " { get; }" : " { set; }");
return(buffer.GetContent());
}
buffer.WriteToTranslation(method.Name);
if (method.IsGenericMethod)
{
WriteGenericArgumentsToTranslation(method.GetGenericArguments(), buffer);
}
WriteParametersToTranslation(method, buffer);
return(buffer.GetContent());
}
private static void WriteModifiersToTranslation(MethodInfo method, TranslationBuffer buffer)
{
WriteAccessibilityToTranslation(method, buffer);
if (method.IsAbstract)
{
buffer.WriteToTranslation("abstract ");
}
else
{
if (method.IsStatic)
{
buffer.WriteToTranslation("static ");
}
if (method.IsVirtual)
{
buffer.WriteToTranslation("virtual ");
}
}
}
private static void WriteGenericArgumentsToTranslation(IList <Type> genericArguments, TranslationBuffer buffer)
{
var genericArgumentTypes = genericArguments;
buffer.WriteToTranslation('<');
for (var i = 0; ;)
{
var argumentType = genericArgumentTypes[i];
buffer.WriteFriendlyName(argumentType);
if (++i == genericArgumentTypes.Count)
{
break;
}
buffer.WriteToTranslation(", ");
}
buffer.WriteToTranslation('>');
}
public void WriteTo(TranslationBuffer buffer)
{
if (WriteToMultipleLines)
{
buffer.WriteOpeningBraceToTranslation();
}
else
{
buffer.WriteToTranslation(" { ");
}
for (var i = 0; ;)
{
_initializerTranslations[i].WriteTo(buffer);
if (++i == Count)
{
break;
}
if (WriteToMultipleLines)
{
buffer.WriteToTranslation(',');
buffer.WriteNewLineToTranslation();
continue;
}
buffer.WriteToTranslation(", ");
}
if (WriteToMultipleLines)
{
buffer.WriteClosingBraceToTranslation();
}
else
{
buffer.WriteToTranslation(" }");
}
}
private static void WriteAccessibilityToTranslation(MethodBase method, TranslationBuffer buffer)
{
if (method.IsPublic)
{
buffer.WriteToTranslation("public ");
}
else if (method.IsAssembly)
{
buffer.WriteToTranslation("internal ");
}
else if (method.IsFamily)
{
buffer.WriteToTranslation("protected ");
}
else if (method.IsFamilyOrAssembly)
{
buffer.WriteToTranslation("protected internal ");
}
else if (method.IsPrivate)
{
buffer.WriteToTranslation("private ");
}
}
protected void WriteClosingCheckedIfNecessary(TranslationBuffer buffer, bool isMultiStatementChecked)
{
if (IsCheckedOperation == false)
{
return;
}
if (isMultiStatementChecked)
{
buffer.WriteClosingBraceToTranslation();
return;
}
buffer.WriteToTranslation(_closingSymbol);
}
private static void WriteParametersToTranslation(MethodBase method, TranslationBuffer buffer)
{
var parameters = method.GetParameters();
if (!parameters.Any())
{
buffer.WriteToTranslation("()");
return;
}
buffer.WriteNewLineToTranslation();
buffer.WriteToTranslation('(');
buffer.Indent();
for (var i = 0; ;)
{
var parameter = parameters[i];
var parameterType = parameter.ParameterType;
buffer.WriteNewLineToTranslation();
if (parameter.IsOut)
{
buffer.WriteToTranslation("out ");
parameterType = parameterType.GetElementType();
}
else if (parameterType.IsByRef)
{
buffer.WriteToTranslation("ref ");
parameterType = parameterType.GetElementType();
}
buffer.WriteFriendlyName(parameterType);
buffer.WriteSpaceToTranslation();
buffer.WriteToTranslation(parameter.Name);
if (++i == parameters.Length)
{
break;
}
buffer.WriteToTranslation(',');
}
buffer.Unindent();
buffer.WriteNewLineToTranslation();
buffer.WriteToTranslation(')');
}
internal static void WriteFriendlyName(
this TranslationBuffer buffer,
Type type,
TranslationSettings settings)
{
if (type.FullName == null)
{
// An open generic parameter Type:
return;
}
if (type.IsArray)
{
buffer.WriteFriendlyName(type.GetElementType(), settings);
buffer.WriteToTranslation("[]");
return;
}
if (!type.IsGenericType())
{
var substitutedTypeName = type.GetSubstitutionOrNull();
if (type.IsNested)
{
buffer.WriteFriendlyName(type.DeclaringType, settings);
buffer.WriteToTranslation('.');
buffer.WriteToTranslation(substitutedTypeName ?? type.Name);
return;
}
if (substitutedTypeName != null)
{
buffer.WriteToTranslation(substitutedTypeName);
return;
}
buffer.WriteTypeNamespaceIfRequired(type, settings);
buffer.WriteToTranslation(type.Name);
return;
}
Type underlyingNullableType;
if ((underlyingNullableType = Nullable.GetUnderlyingType(type)) == null)
{
buffer.WriteGenericTypeName(type, settings);
return;
}
buffer.WriteFriendlyName(underlyingNullableType, settings);
buffer.WriteToTranslation('?');
}
private static void WriteGenericTypeName(
this TranslationBuffer buffer,
Type genericType,
TranslationSettings settings)
{
var typeGenericTypeArguments = genericType.GetGenericTypeArguments();
if (!genericType.IsNested)
{
buffer.WriteTypeNamespaceIfRequired(genericType, settings);
buffer.WriteClosedGenericTypeName(genericType, ref typeGenericTypeArguments, settings);
return;
}
var types = new List <Type> {
genericType
};
// ReSharper disable once PossibleNullReferenceException
while (genericType.IsNested)
{
genericType = genericType.DeclaringType;
types.Add(genericType);
}
buffer.WriteTypeNamespaceIfRequired(genericType, settings);
for (var i = types.Count; ;)
{
buffer.WriteClosedGenericTypeName(types[--i], ref typeGenericTypeArguments, settings);
if (i == 0)
{
return;
}
buffer.WriteToTranslation('.');
}
}
public void WriteTo(TranslationBuffer buffer)
{
buffer.WriteToTranslation(_memberName);
buffer.WriteToTranslation(" = ");
_valueTranslation.WriteTo(buffer);
}
private static void WriteClosedGenericTypeName(
this TranslationBuffer buffer,
Type genericType,
ref Type[] typeGenericTypeArguments,
TranslationSettings settings)
{
var typeName = genericType.Name;
var backtickIndex = typeName.IndexOf("`", StringComparison.Ordinal);
if (backtickIndex == -1)
{
buffer.WriteToTranslation(typeName);
return;
}
var numberOfParameters = int.Parse(typeName.Substring(backtickIndex + 1));
Type[] typeArguments;
if (numberOfParameters == typeGenericTypeArguments.Length)
{
typeArguments = typeGenericTypeArguments;
goto WriteName;
}
switch (numberOfParameters)
{
case 1:
typeArguments = new[] { typeGenericTypeArguments[0] };
break;
case 2:
typeArguments = new[] { typeGenericTypeArguments[0], typeGenericTypeArguments[1] };
break;
default:
typeArguments = new Type[numberOfParameters];
Array.Copy(
typeGenericTypeArguments,
typeArguments,
numberOfParameters);
break;
}
var numberOfRemainingTypeArguments = typeGenericTypeArguments.Length - numberOfParameters;
var typeGenericTypeArgumentsSubset = new Type[numberOfRemainingTypeArguments];
Array.Copy(
typeGenericTypeArguments,
numberOfParameters,
typeGenericTypeArgumentsSubset,
0,
numberOfRemainingTypeArguments);
typeGenericTypeArguments = typeGenericTypeArgumentsSubset;
WriteName:
buffer.WriteGenericTypeName(genericType, numberOfParameters, typeArguments, settings);
}
