private static string GetGenericCloseGlyph(TypeParameterDisplayMode displayMode)
{
switch (displayMode)
{
case TypeParameterDisplayMode.SystemStandard:
return("]");
case TypeParameterDisplayMode.DebuggerStandard:
return(">");
case TypeParameterDisplayMode.CommentStandard:
return("}");
default:
return(string.Empty);
}
}
public string BuildTypeName(IType target, bool shortFormGeneric = false, bool numericTypeParams = false, TypeParameterDisplayMode typeParameterDisplayMode = TypeParameterDisplayMode.SystemStandard)
{
callcount++;
return(TypeExtensions.BuildTypeNameInternal(target, shortFormGeneric, numericTypeParams, typeParameterDisplayMode));
}
internal static string BuildTypeNameInternal(this IType target, bool shortFormGeneric = false, bool numericTypeParams = false, TypeParameterDisplayMode typeParameterDisplayMode = TypeParameterDisplayMode.SystemStandard)
{
switch (target.ElementClassification)
{
case TypeElementClassification.None:
if (target is IGenericParameter)
{
if (numericTypeParams)
{
var genericParameter = (IGenericParameter)target;
if (genericParameter.Parent is IType)
{
return(string.Format("!{0}", genericParameter.Position));
}
else
{
return(string.Format("!!{0}", genericParameter.Position));
}
}
else
{
return(((IGenericParameter)(target)).Name);
}
}
string targetName = target.Name;
var genericTarget = target as IGenericType;
if (typeParameterDisplayMode == TypeParameterDisplayMode.SystemStandard && genericTarget != null && genericTarget.IsGenericConstruct)
{
int count = 0;
if (genericTarget.ElementClassification == TypeElementClassification.None)
{
if ((count = genericTarget.TypeParameters.Count) > 0)
{
targetName += '`' + count.ToString();
}
}
else if (genericTarget.ElementClassification == TypeElementClassification.GenericTypeDefinition)
{
var genericElementType = genericTarget.ElementType as IGenericType;
if (genericElementType != null)
{
if ((count = genericElementType.TypeParameters.Count) > 0)
{
targetName += '`' + count.ToString();
}
}
else
{
targetName += "`?";
}
}
}
if (target.Parent != null && !(target.Parent is INamespaceDeclaration ||
target.Parent is IAssembly))
{
return(string.Format("{0}+{1}", target.Parent.BuildVariedName(shortFormGeneric, numericTypeParams, typeParameterDisplayMode), targetName));
}
else if (!string.IsNullOrEmpty(target.NamespaceName))
{
return(string.Format("{0}.{1}", target.NamespaceName, targetName));
}
else
{
return(targetName);
}
case TypeElementClassification.Array:
if (target is IArrayType)
{
var arrayVariant = target as IArrayType;
if (arrayVariant.Flags == ArrayFlags.Vector)
{
return(string.Format("{0}[]", target.ElementType.BuildTypeName(shortFormGeneric, numericTypeParams)));
}
else if ((arrayVariant.Flags & ArrayFlags.DimensionLengths) == ArrayFlags.DimensionLengths || (arrayVariant.Flags & ArrayFlags.DimensionLowerBounds) == ArrayFlags.DimensionLowerBounds)
{
var lengths = arrayVariant.Lengths;
var lowerBounds = arrayVariant.LowerBounds;
int lengthCount = 0,
lowerBoundCount = 0;
if (lengths != null)
{
lengthCount = lengths.Count;
}
if (lowerBounds != null)
{
lowerBoundCount = lowerBounds.Count;
}
StringBuilder sb = new StringBuilder();
bool first = true;
for (int i = 0; i < arrayVariant.ArrayRank; i++)
{
if (first)
{
first = false;
}
else
{
sb.Append(",");
}
bool addedDots;
if (addedDots = (i < lowerBoundCount))
{
sb.AppendFormat("{0}...", lowerBounds[i]);
}
if (i < lengthCount)
{
if (addedDots)
{
sb.Append(lowerBounds[i] + lengths[i] - 1);
}
else
{
sb.AppendFormat("0...{0}", lengths[i] - 1);
}
}
}
return(string.Format("{0}[{1}]", target.ElementType.BuildTypeName(shortFormGeneric, numericTypeParams), sb.ToString()));
}
else
{
return(string.Format("{0}[{1}]", target.ElementType.BuildTypeName(shortFormGeneric, numericTypeParams), ','.Repeat(arrayVariant.ArrayRank - 1)));
}
}
else
{
return(string.Format("{0}[?,...]", target.ElementType.BuildTypeName(shortFormGeneric, numericTypeParams)));
}
case TypeElementClassification.Nullable:
return(string.Format("{0}?", target.ElementType.BuildTypeName(shortFormGeneric, numericTypeParams)));
case TypeElementClassification.Pointer:
return(string.Format("{0}*", target.ElementType.BuildTypeName(shortFormGeneric, numericTypeParams)));
case TypeElementClassification.Reference:
return(string.Format("{0}&", target.ElementType.BuildTypeName(shortFormGeneric, numericTypeParams)));
case TypeElementClassification.GenericTypeDefinition:
if (target is IGenericType)
{
/*Apply the rules across the generic parameters. With an alternate route for numeric identity. */
return(string.Format("{0}{2}{1}{3}", target.ElementType.BuildTypeName(typeParameterDisplayMode: typeParameterDisplayMode), string.Join(",",
((IGenericType)(target)).GenericParameters.OnAll(genericReplacement =>
{
if (shortFormGeneric)
{
if (genericReplacement.IsGenericTypeParameter)
{
if (numericTypeParams)
{
var genericParameterReplacement = (IGenericParameter)genericReplacement;
if (genericParameterReplacement.Parent is IType)
{
return string.Format("!{0}", genericParameterReplacement.Position);
}
else
{
return string.Format("!!{0}", genericParameterReplacement.Position);
}
}
else
{
return genericReplacement.Name;
}
}
else
{
return genericReplacement.BuildTypeName(shortFormGeneric, true);
}
}
else if (genericReplacement.IsGenericTypeParameter)
{
if (numericTypeParams && typeParameterDisplayMode != TypeParameterDisplayMode.CommentStandard)
{
var genericParameterReplacement = (IGenericParameter)genericReplacement;
if (genericParameterReplacement.Parent is IType)
{
return string.Format("[!{0}]", genericParameterReplacement.Position);
}
else
{
return string.Format("[!!{0}]", genericParameterReplacement.Position);
}
}
else
{
return string.Format("[{0}]", genericReplacement.Name);
}
}
else if (genericReplacement.Assembly == null)
{
return genericReplacement.FullName;
}
else if (typeParameterDisplayMode == TypeParameterDisplayMode.CommentStandard)
{
return genericReplacement.BuildTypeName(shortFormGeneric, numericTypeParams, typeParameterDisplayMode);
}
else
{
try
{
IAssembly replacementAssembly = genericReplacement.Assembly;
return string.Format("[{0}, {1}]", genericReplacement.FullName, replacementAssembly.ToString());
}
//For Symbol types.
catch (NotSupportedException)
{
return string.Format("{0}", genericReplacement.FullName);
}
}
}).ToArray()), GetGenericOpenGlyph(typeParameterDisplayMode), GetGenericCloseGlyph(typeParameterDisplayMode)));
}
else /* If they report they're generic, but do not implement the proper interface, we're somewhat out of luck. */
{
return(string.Format("{0}{1}[?],...{2}", target.ElementType.BuildTypeName(true, numericTypeParams, typeParameterDisplayMode), GetGenericOpenGlyph(typeParameterDisplayMode), GetGenericCloseGlyph(typeParameterDisplayMode)));
}
}
return(null);
}
/// <summary>
/// Debug method used to display the name of a type in a near CLR-identical manner.
/// </summary>
/// <param name="target">The <see cref="IType"/> to build the type name for.</param>
/// <param name="shortFormGeneric">Whether the names of the type-parameters
/// within the type are shortened for use within the brackets
/// of a generic-type instance vs. their full type-name.</param>
/// <param name="numericTypeParams">Whether type-parameters are shown as numbers.</param>
/// <param name="typeParameterDisplayMode">Whether to use angle brackets or square brackets
/// based upon the call-site's intent. <see cref="TypeParameterDisplayMode.SystemStandard"/> shows
/// square brackets ('[' and ']'), and <see cref="TypeParameterDisplayMode.DebuggerStandard"/>
/// shows angle brackets ('<' and '>').</param>
/// <returns></returns>
public static string BuildTypeName(this IType target, bool shortFormGeneric = false, bool numericTypeParams = false, TypeParameterDisplayMode typeParameterDisplayMode = TypeParameterDisplayMode.SystemStandard)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
var identityManager = target.IdentityManager;
if (identityManager == null)
{
return(target.Name);
}
ITypeNameBuilderService builderService;
if (identityManager.TryGetService(IdentityManagerServiceGuids.TypeNameBuilderService, out builderService))
{
return(builderService.BuildTypeName(target, shortFormGeneric, numericTypeParams, typeParameterDisplayMode));
}
return(target.Name);
}
private static string BuildMemberName(this IMember member, bool shortFormGeneric = false, bool numericTypeParams = false, TypeParameterDisplayMode typeParameterDisplayMode = TypeParameterDisplayMode.SystemStandard)
{
if (member.Parent is IType)
{
return(string.Format("{0}::{1}", ((IType)(member.Parent)).BuildTypeName(shortFormGeneric, numericTypeParams, typeParameterDisplayMode), member.ToString()));
}
else if (member.Parent is INamespaceDeclaration)
{
return(string.Format("{0}.{1}", ((INamespaceDeclaration)(member.Parent)).FullName, member.ToString()));
}
else if (member.Parent is IMember)
{
return(string.Format("{0}->{1}", ((IMember)(member.Parent)).BuildMemberName(shortFormGeneric, numericTypeParams, typeParameterDisplayMode), member.ToString()));
}
throw new ArgumentException("Unrecognized entity in member nesting chain.");
}
private static string BuildVariedName(this ITypeParent target, bool shortFormGeneric = false, bool numericTypeParams = false, TypeParameterDisplayMode typeParameterDisplayMode = TypeParameterDisplayMode.SystemStandard)
{
if (target is IMember)
{
return(((IMember)(target)).BuildMemberName(shortFormGeneric, numericTypeParams, typeParameterDisplayMode));
}
else if (target is IType)
{
return(((IType)(target)).BuildTypeName(shortFormGeneric, numericTypeParams, typeParameterDisplayMode));
}
else if (target is INamespaceDeclaration)
{
return(((INamespaceDeclaration)target).FullName);
}
throw new ArgumentException("Unrecognized entity in type nesting chain.");
}
