public override bool Equals(object obj)
{
if ((object)this == obj)
{
return(true);
}
SubstitutedMethodSymbol other = obj as SubstitutedMethodSymbol;
if ((object)other == null)
{
return(false);
}
if ((object)this.OriginalDefinition != (object)other.OriginalDefinition &&
this.OriginalDefinition != other.OriginalDefinition)
{
return(false);
}
// This checks if the methods have the same definition and the type parameters on the containing types have been
// substituted in the same way.
if (this.ContainingType != other.ContainingType)
{
return(false);
}
// If both are declarations, then we don't need to check type arguments
// If exactly one is a declaration, then they re not equal
bool selfIsDeclaration = (object)this == (object)this.ConstructedFrom;
bool otherIsDeclaration = (object)other == (object)other.ConstructedFrom;
// PERF: VSadov specifically replaced the short-circuited operators in changeset #24717.
if (selfIsDeclaration | otherIsDeclaration)
{
return(selfIsDeclaration & otherIsDeclaration);
}
// This checks if the type parameters on the method itself have been substituted in the same way.
int arity = this.Arity;
for (int i = 0; i < arity; i++)
{
// TODO: what about annotations
if (this.TypeArguments[i].TypeSymbol != other.TypeArguments[i].TypeSymbol)
{
return(false);
}
}
return(true);
}
static bool wasConstructedForAnnotations(SubstitutedMethodSymbol method)
{
var typeArguments = method.TypeArgumentsWithAnnotations;
var typeParameters = method.OriginalDefinition.TypeParameters;
for (int i = 0; i < typeArguments.Length; i++)
{
if (!typeParameters[i].Equals(
typeArguments[i].Type,
TypeCompareKind.ConsiderEverything))
{
return(false);
}
}
return(true);
}
internal static MethodSymbol SubstituteMethodSymbolIfNeeded(MethodSymbol methodSymbol, IGenericContext genericContext)
{
if (MetadataGenericContext.IsNullOrEmptyOrNoSpecializations(genericContext))
{
return methodSymbol;
}
var method = new MetadataMethodAdapter(methodSymbol);
if (!method.IsGenericMethodDefinition && !method.DeclaringType.IsGenericTypeDefinition)
{
return methodSymbol;
}
var resolvedMethodSymbol = methodSymbol;
if (method.DeclaringType.IsGenericTypeDefinition)
{
var constructedContainingType = SubstituteTypeSymbolIfNeeded(methodSymbol.ContainingType, genericContext);
var substitutedNamedTypeSymbol = constructedContainingType as SubstitutedNamedTypeSymbol;
if (substitutedNamedTypeSymbol != null)
{
resolvedMethodSymbol = new SubstitutedMethodSymbol(
substitutedNamedTypeSymbol,
methodSymbol.ConstructedFrom.OriginalDefinition);
}
else
{
var typeDef = (method.DeclaringType as MetadataTypeAdapter).TypeDef;
constructedContainingType = SubstituteTypeSymbolIfNeeded(typeDef, genericContext);
resolvedMethodSymbol = (constructedContainingType as ArrayTypeSymbol).GetMembers(methodSymbol.Name)[0] as MethodSymbol;
}
}
if (method.IsGenericMethodDefinition || method.IsGenericMethod)
{
return ConstructMethodSymbol(resolvedMethodSymbol, methodSymbol.TypeSubstitution, genericContext);
}
return resolvedMethodSymbol;
}