/// <summary>
/// Get any constraints for the specified <see cref="TypeParameter"/> on this method, or on the base virtual method if this method is an override.
/// </summary>
public List <TypeParameterConstraint> GetTypeParameterConstraints(TypeParameter typeParameter)
{
// Override methods don't specify constraints - they inherit them from the base virtual method.
// In order to handle invalid code, just look in the first occurrence of constraints, searching
// any base method if the current one is an override.
if (_constraintClauses != null && _constraintClauses.Count > 0)
{
foreach (ConstraintClause constraintClause in _constraintClauses)
{
if (constraintClause.TypeParameter.Reference == typeParameter)
{
return(constraintClause.Constraints);
}
}
}
else
{
MethodRef baseMethodRef = FindBaseMethod();
if (baseMethodRef != null)
{
// If the constraints are from a base method, we have to translate the type parameter
int index = FindTypeParameterIndex(typeParameter);
TypeParameterRef typeParameterRef = baseMethodRef.GetTypeParameter(index);
return(baseMethodRef.GetTypeParameterConstraints(typeParameterRef));
}
}
return(null);
}
/// <summary>
/// Determine if the current reference refers to the same code object as the specified reference.
/// </summary>
public override bool IsSameRef(SymbolicRef symbolicRef)
{
if (!(symbolicRef is TypeParameterRef))
{
return(false);
}
TypeParameterRef typeParameterRef = (TypeParameterRef)symbolicRef;
object reference = GetReferencedType();
object typeParameterRefReference = typeParameterRef.GetReferencedType();
if (reference != typeParameterRefReference)
{
// We also have to consider the references the same if the Name and NamespaceNames match.
// This can occur when types are present both in an assembly reference, and also as CodeDOM
// objects (either in the current project, or a referenced project). This can occur if one
// or both types are in a project with assembly references instead of project references to
// a type that is defined in the current solution, which isn't uncommon - it will occur in
// "master" solutions that include projects that are also used in other solutions, and also
// if a project in the solution uses a non-supported language and so is referenced by its
// assembly.
if (Name != typeParameterRef.Name || NamespaceName != typeParameterRef.NamespaceName)
{
return(false);
}
// With type parameters, the declaring (parent) type names must also match for the type
// parameters to be considered the same.
string declaringTypeName = GetDeclaringTypeOrMethodName(reference);
string typeParameterRefDeclaringTypeName = typeParameterRef.GetDeclaringTypeOrMethodName();
if (declaringTypeName == null || typeParameterRefDeclaringTypeName == null ||
declaringTypeName != typeParameterRefDeclaringTypeName)
{
return(false);
}
}
return(HasSameArrayRanks(typeParameterRef));
}
/// <summary>
/// Create a <see cref="DocTypeParam"/>.
/// </summary>
public DocTypeParam(TypeParameterRef typeParameterRef, params DocComment[] docComments)
: base(typeParameterRef, docComments)
{
}
/// <summary>
/// Create a <see cref="DocTypeParam"/>.
/// </summary>
public DocTypeParam(TypeParameterRef typeParameterRef, string text)
: base(typeParameterRef, text)
{
}
/// <summary>
/// Create a <see cref="DocTypeParamRef"/>.
/// </summary>
public DocTypeParamRef(TypeParameterRef typeParameterRef)
: base(typeParameterRef, (string)null)
{
}
/// <summary>
/// Create a <see cref="ConstraintClause"/>.
/// </summary>
public ConstraintClause(TypeParameterRef typeParameterRef, params TypeParameterConstraint[] constraints)
: this((SymbolicRef)typeParameterRef, constraints)
{
}
