internal ConstructedGenericTypeData(TypeDefinitionData genericTypeDefinition, IEnumerable <TypeData> genericArguments)
: base(genericTypeDefinition.Name, genericTypeDefinition.Accessibility, genericTypeDefinition.MemberFlags, genericTypeDefinition.TypeKind)
{
GenericTypeDefinition = genericTypeDefinition;
ContainingType = genericTypeDefinition.ContainingType;
_isNullable = genericTypeDefinition.IsType(typeof(Nullable <>));
GenericArguments = new GenericTypeArgumentCollection(genericArguments);
genericTypeDefinition.RegisterConstructedGenericTypeData(this);
genericTypeDefinition.AssemblyData.RegisterForFinalize(this);
}
internal bool DoesMatch(GenericTypeArgumentCollection other)
{
if (this.Count != other.Count)
{
return(false);
}
for (int i = 0; i < this.Count; i++)
{
if (this[i].DoesMatch(other[i]) == false)
{
return(false);
}
}
return(true);
}
/// <inheritdoc/>
internal override MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments)
{
var replacedElementType = (TypeData)ElementType.ReplaceGenericTypeParameters(genericParameters, genericArguments);
if (replacedElementType == ElementType)
{
return(this);
}
return(replacedElementType.GetPointerType());
}
/// <summary>
/// Replaces all type parameters used by the member with their associated generic arguments specified in a constructed generic type.
/// </summary>
/// <param name="declaringMemberKind">The type of member owning the parameter collection.</param>
/// <param name="genericParameters">The generic parameters being replaced.</param>
/// <param name="genericArguments">The generic arguments replacing the parameters.</param>
/// <returns>A new member with the replaced type parameters or the current instance if the member does not use any of the generic parameters.</returns>
#endif
internal ParameterCollection ReplaceGenericTypeParameters(MetadataItemKinds declaringMemberKind, GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments)
{
ParameterCollection replacedParameters = null;
for (int i = 0; i < this.Count; i++)
{
var currentParameter = this[i];
var replacedParameter = currentParameter.ReplaceGenericTypeParameters(declaringMemberKind, genericParameters, genericArguments);
if (replacedParameter == currentParameter)
{
continue;
}
if (replacedParameters == null)
{
replacedParameters = new ParameterCollection();
replacedParameters._parameters.AddRange(_parameters);
}
replacedParameters._parameters[i] = replacedParameter;
}
return(replacedParameters ?? this);
}
/// <summary>
/// Adds in the fully qualified information for the type name if necessary.
/// </summary>
/// <param name="unqualifiedName">The unqualified name of the type.</param>
/// <param name="fullyQualify">Indicates whether the type name should be fully qualified with declaring type and namespace names.</param>
/// <param name="includeGenericInfo">Indicates whether generic parameters and arguments should be included in type names.</param>
/// <param name="genericArguments">
/// The generic arguments used to parameterize a type. For nested types, this will include the arguments for the declaring type before the arguments
/// for the nested type.
/// </param>
internal string PostProcessUnqualifiedName(string unqualifiedName, bool fullyQualify, bool includeGenericInfo, GenericTypeArgumentCollection genericArguments)
{
if (fullyQualify)
{
if (ContainingType != null)
{
return(ContainingType.GetDisplayName(fullyQualify, includeGenericInfo, genericArguments) + "." + unqualifiedName);
}
var namespaceName = GetNamespaceName();
if (string.IsNullOrEmpty(namespaceName) == false)
{
return(namespaceName + "." + unqualifiedName);
}
}
return(unqualifiedName);
}
/// <summary> /// Gets the display name for the type, which can be used for generating user-readable messages about the type. /// </summary> /// <param name="fullyQualify">Indicates whether the type name should be fully qualified with declaring type and namespace names.</param> /// <param name="includeGenericInfo">Indicates whether generic parameters and arguments should be included in type names.</param> /// <param name="genericArguments"> /// The generic arguments used to parameterize a type. For nested types, this will include the arguments for the declaring type before the arguments /// for the nested type. /// </param> /// <returns>The display name of the type.</returns> internal abstract string GetDisplayName(bool fullyQualify, bool includeGenericInfo, GenericTypeArgumentCollection genericArguments);
/// <summary>
/// Replaces all type parameters used by the member with their associated generic arguments specified in a constructed generic type.
/// </summary>
/// <param name="genericParameters">The generic parameters being replaced.</param>
/// <param name="genericArguments">The generic arguments replacing the parameters.</param>
/// <returns>A new member with the replaced type parameters or the current instance if the member does not use any of the generic parameters.</returns>
#endif
internal override MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments)
{
var replacedType = (TypeData)this.Type.ReplaceGenericTypeParameters(genericParameters, genericArguments);
var replacedParameters = this.Parameters.ReplaceGenericTypeParameters(this.MetadataItemKind, genericParameters, genericArguments);
if (replacedType == this.Type &&
replacedParameters == this.Parameters)
{
return(this);
}
return(new IndexerData(this.Name, this.Accessibility, this.MemberFlags, replacedType, this.IsTypeDynamic, replacedParameters, this.GetMethodAccessibility, this.SetMethodAccessibility));
}
internal ImplementedInterfacesCollection ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments)
{
return(new ImplementedInterfacesCollection(this.Select(im => (DeclaringTypeData)im.ReplaceGenericTypeParameters(genericParameters, genericArguments))));
}
/// <inheritdoc/>
internal override MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments)
{
List <TypeData> replacedGenericArguments = null;
for (int i = 0; i < GenericArguments.Count; i++)
{
var currentArgument = GenericArguments[i];
var replacedArgument = (TypeData)currentArgument.ReplaceGenericTypeParameters(genericParameters, genericArguments);
if (replacedArgument == currentArgument)
{
continue;
}
if (replacedGenericArguments == null)
{
replacedGenericArguments = new List <TypeData>(GenericArguments);
}
replacedGenericArguments[i] = replacedArgument;
}
if (replacedGenericArguments != null)
{
return(GenericTypeDefinition.GetConstructedGenericTypeData(replacedGenericArguments));
}
return(this);
}
/// <inheritdoc/>
internal override MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments)
{
var replacedType = (TypeData)Type.ReplaceGenericTypeParameters(genericParameters, genericArguments);
if (replacedType == Type)
{
return(this);
}
return(new PropertyData(Name, Accessibility, MemberFlags, replacedType, IsTypeDynamic, GetMethodAccessibility, SetMethodAccessibility));
}
/// <summary>
/// Replaces all type parameters used by the member with their associated generic arguments specified in a constructed generic type.
/// </summary>
/// <param name="declaringMemberKind">The type of member owning the parameter collection.</param>
/// <param name="genericParameters">The generic parameters being replaced.</param>
/// <param name="genericArguments">The generic arguments replacing the parameters.</param>
/// <returns>A new member with the replaced type parameters or the current instance if the member does not use any of the generic parameters.</returns>
#endif
internal ParameterData ReplaceGenericTypeParameters(MetadataItemKinds declaringMemberKind, GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments)
{
var replacedType = (TypeData)this.Type.ReplaceGenericTypeParameters(genericParameters, genericArguments);
if (replacedType == this.Type)
{
return(this);
}
return(new ParameterData(declaringMemberKind, this.Name, replacedType, this.Modifer, _flags, this.DefaultValue));
}
/// <inheritdoc/> internal override MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments) => GenericParameters == genericParameters?GetConstructedGenericTypeData(genericArguments) : (MemberDataBase)this;
/// <inheritdoc/>
internal override MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments)
{
for (int i = 0; i < genericParameters.Count; i++)
{
if (this == genericParameters[i])
{
// TODO_Refactor: Re-add something like this?
//Debug.Assert(this.GenericParameterPosition == i, "We are expecting the generic argument to be in its proper position.");
return(genericArguments[i]);
}
}
return(this);
}
/// <summary>
/// Replaces all type parameters used by the member with their associated generic arguments specified in a constructed generic type.
/// </summary>
/// <param name="genericParameters">The generic parameters being replaced.</param>
/// <param name="genericArguments">The generic arguments replacing the parameters.</param>
/// <returns>A new member with the replaced type parameters or the current instance if the member does not use any of the generic parameters.</returns>
#endif
internal override MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments)
{
var replacedElementType = (TypeData)this.ElementType.ReplaceGenericTypeParameters(genericParameters, genericArguments);
if (replacedElementType == this.ElementType)
{
return(this);
}
return
(replacedElementType.GetArrayType(this.ArrayRank) ??
new ArrayTypeData(
this.Name,
this.Accessibility,
this.MemberFlags,
this.TypeKind,
replacedElementType,
this.ArrayRank));
}
/// <summary>
/// Replaces all type parameters used by the member with their associated generic arguments specified in a constructed generic type.
/// </summary>
/// <param name="genericParameters">The generic parameters being replaced.</param>
/// <param name="genericArguments">The generic arguments replacing the parameters.</param>
/// <returns>A new member with the replaced type parameters or the current instance if the member does not use any of the generic parameters.</returns>
#endif
internal override MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments)
{
var replacedType = (TypeData)this.Type.ReplaceGenericTypeParameters(genericParameters, genericArguments);
if (replacedType == this.Type)
{
return(this);
}
return(new EventData(this.Name, this.Accessibility, this.MemberFlags, replacedType));
}
/// <summary>
/// Replaces all type parameters used by the member with their associated generic arguments specified in a constructed generic type.
/// </summary>
/// <param name="genericParameters">The generic parameters being replaced.</param>
/// <param name="genericArguments">The generic arguments replacing the parameters.</param>
/// <returns>A new member with the replaced type parameters or the current instance if the member does not use any of the generic parameters.</returns>
#endif
internal override MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments)
{
var replacedParameters = this.Parameters.ReplaceGenericTypeParameters(this.MetadataItemKind, genericParameters, genericArguments);
if (replacedParameters == this.Parameters)
{
return(this);
}
return(new ConstructorData(this.Name, this.Accessibility, this.MemberFlags, replacedParameters));
}
/// <inheritdoc/>
internal override string GetDisplayName(bool fullyQualify, bool includeGenericInfo, GenericTypeArgumentCollection genericArguments)
{
if (IsNullable(out TypeData underlyingType))
{
return(underlyingType.GetDisplayName(fullyQualify: false, includeGenericInfo: includeGenericInfo) + '?');
}
var genericArgumentsResolved = genericArguments ?? GenericArguments;
var rootName = GenericTypeDefinition.GetDisplayName(fullyQualify: false, includeGenericInfo: false);
if (includeGenericInfo)
{
var parentGenericArgumentCount = ContainingType == null ? 0 : ContainingType.GenericArity;
rootName += genericArgumentsResolved.GetGenericArgumentListDisplayText(includeGenericInfo, parentGenericArgumentCount, GenericArguments.Count - parentGenericArgumentCount);
}
return(PostProcessUnqualifiedName(rootName, fullyQualify, includeGenericInfo, genericArgumentsResolved));
}
/// <summary>
/// Gets the display name for the type, which can be used for generating user-readable messages about the type.
/// </summary>
/// <param name="fullyQualify">Indicates whether the type name should be fully qualified with declaring type and namespace names.</param>
/// <param name="includeGenericInfo">Indicates whether generic parameters and arguments should be included in type names.</param>
/// <param name="genericArguments">
/// The generic arguments used to parameterize a type. For nested types, this will include the arguments for the declaring type before the arguments
/// for the nested type.
/// </param>
/// <returns>The display name of the type.</returns>
#endif
internal override string GetDisplayName(bool fullyQualify, bool includeGenericInfo, GenericTypeArgumentCollection genericArguments)
{
string primitiveTypeName;
if (_primitiveTypeNames.TryGetValue(this.FullName, out primitiveTypeName))
{
return(primitiveTypeName);
}
var rootName = this.Name;
var tickIndex = rootName.LastIndexOf('`');
if (0 <= tickIndex)
{
rootName = rootName.Substring(0, tickIndex);
}
if (includeGenericInfo)
{
var declaringTypeGenericArity = this.DeclaringType == null ? 0 : this.DeclaringType.GenericArity;
if (genericArguments != null)
{
rootName += genericArguments.GetGenericArgumentListDisplayText(includeGenericInfo, declaringTypeGenericArity, this.GenericParameters.Count - declaringTypeGenericArity);
}
else if (this.GenericParameters != null) // While initializing, this.GenericParameters could be null and we don't want this throwing an exception
{
rootName += this.GenericParameters.GetParameterListText(skipCount: declaringTypeGenericArity);
}
}
return(this.PostProcessUnqualifiedName(rootName, fullyQualify, includeGenericInfo, genericArguments));
}
/// <summary>
/// Replaces all type parameters used by the member with their associated generic arguments specified in a constructed generic type.
/// </summary>
/// <param name="genericParameters">The generic parameters being replaced.</param>
/// <param name="genericArguments">The generic arguments replacing the parameters.</param>
/// <returns>A new member with the replaced type parameters or the current instance if the member does not use any of the generic parameters.</returns>
#endif
internal override MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments)
{
if (this.GenericParameters == genericParameters)
{
return(this.GetConstructedGenericTypeData(genericArguments));
}
return(this);
}
/// <summary>
/// Replaces all type parameters used by the member with their associated generic arguments specified in a constructed generic type.
/// </summary>
/// <param name="genericParameters">The generic parameters being replaced.</param>
/// <param name="genericArguments">The generic arguments replacing the parameters.</param>
/// <returns>A new member with the replaced type parameters or the current instance if the member does not use any of the generic parameters.</returns>
#endif
internal abstract MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments);
/// <inheritdoc/>
internal override MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments)
{
var replacedType = (TypeData)Type.ReplaceGenericTypeParameters(genericParameters, genericArguments);
var replacedParameters = Parameters.ReplaceGenericTypeParameters(MetadataItemKind, genericParameters, genericArguments);
if (replacedType == Type &&
replacedParameters == Parameters)
{
return(this);
}
return(new MethodData(Name, Accessibility, MemberFlags, replacedType, IsTypeDynamic, GenericParameters, IsExtensionMethod, replacedParameters));
}
/// <summary>
/// Replaces all type parameters used by the member with their associated generic arguments specified in a constructed generic type.
/// </summary>
/// <param name="genericParameters">The generic parameters being replaced.</param>
/// <param name="genericArguments">The generic arguments replacing the parameters.</param>
/// <returns>A new member with the replaced type parameters or the current instance if the member does not use any of the generic parameters.</returns>
#endif
internal override MemberDataBase ReplaceGenericTypeParameters(GenericTypeParameterCollection genericParameters, GenericTypeArgumentCollection genericArguments)
{
var replacedType = (TypeData)this.Type.ReplaceGenericTypeParameters(genericParameters, genericArguments);
if (replacedType == this.Type)
{
return(this);
}
Debug.Fail("It was assumed that constants cannot be generic");
return(new ConstantData(this.Name, this.Accessibility, this.MemberFlags, replacedType, this.IsTypeDynamic, this.Value));
}
