/// <inheritdoc/>
internal override bool IsEquivalentToNewMember(MemberDataBase newMember, AssemblyFamily newAssemblyFamily)
{
if (base.IsEquivalentToNewMember(newMember, newAssemblyFamily) == false)
{
return(false);
}
var other = newMember as ConstructedGenericTypeData;
if (other == null)
{
return(false);
}
if (GenericTypeDefinition.IsEquivalentToNew(other.GenericTypeDefinition, newAssemblyFamily) == false)
{
return(false);
}
if (GenericArguments.Count != other.GenericArguments.Count)
{
return(false);
}
for (int i = 0; i < GenericArguments.Count; i++)
{
if (GenericArguments[i].IsEquivalentToNewMember(other.GenericArguments[i], newAssemblyFamily) == false)
{
return(false);
}
}
return(true);
}
internal void PopulateMembers(TypeDefinition underlyingType)
{
foreach (var member in underlyingType.GetMembers())
{
this.AddMember(MemberDataBase.MemberDataFromReflection(member, this));
}
}
internal ParameterData(ParameterDefinition underlyingParameter, MemberDataBase declaringMember)
{
var modifer = ParameterModifier.None;
var parameterType = underlyingParameter.ParameterType;
var byReferenceType = parameterType as ByReferenceType;
if (byReferenceType != null)
{
modifer = underlyingParameter.IsOut ? ParameterModifier.Out : ParameterModifier.Ref;
parameterType = byReferenceType.ElementType;
}
this.DeclaringMemberKind = declaringMember.MetadataItemKind;
this.Modifer = modifer;
this.Name = underlyingParameter.Name;
this.Type = TypeData.FromType(parameterType);
if (underlyingParameter.IsOptional)
{
_flags |= InternalFlags.IsOptional;
this.DefaultValue = Utilities.PreprocessConstantValue(parameterType, underlyingParameter.GetDefualtValue());
}
if (underlyingParameter.CustomAttributes.Any(c => c.AttributeType.EqualsType(typeof(ParamArrayAttribute))))
{
_flags |= InternalFlags.IsParamsArray;
}
if (underlyingParameter.IsDynamicType())
{
_flags |= InternalFlags.IsTypeDynamic;
}
}
/// <summary>
/// Indicates whether the current member can override the specified member from a base type.
/// </summary>
/// <param name="baseMember">The member from the base type.</param>
/// <returns>True if the current member can override the base member; False otherwise.</returns>
#endif
internal override bool CanOverrideMember(MemberDataBase baseMember)
{
if (base.CanOverrideMember(baseMember) == false)
{
return(false);
}
return(this.Type == ((TypedMemberDataBase)baseMember).Type);
}
/// <summary>
/// Indicates whether a new member of the same type and name is logically the same member as the current member, just from a newer build.
/// </summary>
#endif
internal virtual bool IsEquivalentToNewMember(MemberDataBase newMember, AssemblyFamily newAssemblyFamily)
{
if (this.IsNameUsedToVerifyEquivalence && this.Name != newMember.Name)
{
return(false);
}
return(this.MetadataItemKind == newMember.MetadataItemKind);
}
/// <summary>
/// Indicates whether the current member can override the specified member from a base type.
/// </summary>
/// <param name="baseMember">The member from the base type.</param>
/// <returns>True if the current member can override the base member; False otherwise.</returns>
#endif
internal override bool CanOverrideMember(MemberDataBase baseMember)
{
if (base.CanOverrideMember(baseMember) == false)
{
return(false);
}
var otherMethodBase = (MethodDataBase)baseMember;
return(this.Parameters.IsEquivalentTo(otherMethodBase.Parameters));
}
/// <summary>
/// Indicates whether a new member of the same type and name is logically the same member as the current member, just from a newer build.
/// </summary>
#endif
internal override bool IsEquivalentToNewMember(MemberDataBase newMember, AssemblyFamily newAssemblyFamily)
{
var newType = newMember as TypeDefinitionData;
if (newType == null)
{
return(false);
}
return(this.IsEquivalentToNewTypeHelper(newType, newAssemblyFamily, ignoreNewOptionalParameters: false));
}
/// <inheritdoc/>
internal override bool CanOverrideMember(MemberDataBase baseMember)
{
if (base.CanOverrideMember(baseMember) == false)
{
return(false);
}
var otherMethod = (MethodData)baseMember;
return(GenericParameters.Count == otherMethod.GenericParameters.Count);
}
/// <summary>
/// Indicates whether the current member can override the specified member from a base type.
/// </summary>
/// <param name="baseMember">The member from the base type.</param>
/// <returns>True if the current member can override the base member; False otherwise.</returns>
#endif
internal override bool CanOverrideMember(MemberDataBase baseMember)
{
if (base.CanOverrideMember(baseMember) == false)
{
return(false);
}
var otherConstructor = (ConstructorData)baseMember;
return(this.Parameters.IsEquivalentTo(otherConstructor.Parameters));
}
bool IParameterizedItem.IsEquivalentToNewMember(MemberDataBase newMember, AssemblyFamily newAssemblyFamily, bool ignoreNewOptionalParameters)
{
var newConstructor = newMember as ConstructorData;
if (newConstructor == null)
{
return(false);
}
return(this.IsEquivalentToNewMember(newConstructor, newAssemblyFamily, ignoreNewOptionalParameters));
}
/// <inheritdoc/>
internal override bool IsEquivalentToNewMember(MemberDataBase newMember, AssemblyFamily newAssemblyFamily)
{
if (base.IsEquivalentToNewMember(newMember, newAssemblyFamily) == false)
{
return(false);
}
var otherMethod = (MethodData)newMember;
return(GenericParameters.Count == otherMethod.GenericParameters.Count);
}
/// <summary>
/// Indicates whether a new member of the same type and name is logically the same member as the current member, just from a newer build.
/// </summary>
#endif
internal override bool IsEquivalentToNewMember(MemberDataBase newMember, AssemblyFamily newAssemblyFamily)
{
var newConstructor = newMember as ConstructorData;
if (newConstructor == null)
{
return(false);
}
return(this.IsEquivalentToNewMember(newConstructor, newAssemblyFamily, ignoreNewOptionalParameters: false));
}
/// <summary>
/// Indicates whether a new member of the same type and name is logically the same member as the current member, just from a newer build.
/// </summary>
#endif
internal override bool IsEquivalentToNewMember(MemberDataBase newMember, AssemblyFamily newAssemblyFamily)
{
if (base.IsEquivalentToNewMember(newMember, newAssemblyFamily) == false)
{
return(false);
}
var other = newMember as TypeWithElementData;
return
(other != null &&
this.ElementType.IsEquivalentToNew(other.ElementType, newAssemblyFamily));
}
/// <summary>
/// Indicates whether a new member of the same type and name is logically the same member as the current member, just from a newer build.
/// </summary>
#endif
internal override bool IsEquivalentToNewMember(MemberDataBase newMember, AssemblyFamily newAssemblyFamily)
{
if (base.IsEquivalentToNewMember(newMember, newAssemblyFamily) == false)
{
return(false);
}
var other = newMember as ArrayTypeData;
if (other == null)
{
return(false);
}
return(this.ArrayRank == other.ArrayRank);
}
internal ParameterData(IParameterSymbol parameterSymbol, MemberDataBase declaringMember)
{
Context = declaringMember.Context;
var parameterType = parameterSymbol.Type;
ParameterModifier modifer;
switch (parameterSymbol.RefKind)
{
case RefKind.None:
modifer = ParameterModifier.None;
break;
case RefKind.Out:
modifer = ParameterModifier.Out;
break;
case RefKind.Ref:
modifer = ParameterModifier.Ref;
break;
default:
throw new InvalidOperationException($"Unknown RefKind value: {parameterSymbol.RefKind}");
}
DeclaringMemberKind = declaringMember.MetadataItemKind;
Modifer = modifer;
Name = parameterSymbol.Name;
Type = Context.GetTypeData(parameterType);
if (parameterSymbol.IsOptional)
{
_flags |= InternalFlags.IsOptional;
DefaultValue = Utilities.PreprocessConstantValue(parameterType, parameterSymbol.ExplicitDefaultValue);
}
if (parameterSymbol.IsParams)
{
_flags |= InternalFlags.IsParamsArray;
}
if (parameterSymbol.Type.TypeKind == TypeKind.Dynamic)
{
_flags |= InternalFlags.IsTypeDynamic;
}
}
/// <summary>
/// Indicates whether the current member can override the specified member from a base type.
/// </summary>
/// <param name="baseMember">The member from the base type.</param>
/// <returns>True if the current member can override the base member; False otherwise.</returns>
#endif
internal virtual bool CanOverrideMember(MemberDataBase baseMember)
{
// Static members cannot be overridden
if (this.IsStatic || baseMember.IsStatic)
{
return(false);
}
// Members which are not virtual, abstract, or override cannot be overridden.
if (this.IsVirtualCallType == false || baseMember.IsVirtualCallType == false)
{
return(false);
}
return
(this.Accessibility == baseMember.Accessibility &&
this.Name == baseMember.Name);
}
/// <summary>
/// Adds the specified member to the declaring type.
/// </summary>
internal void AddMember(MemberDataBase member)
{
if (member == null)
{
return;
}
if (member.Accessibility != Accessibility.Public && IsSealed)
{
return;
}
if (_membersByName.TryGetValue(member.Name, out List <MemberDataBase> members) == false)
{
members = new List <MemberDataBase>();
_membersByName[member.Name] = members;
}
members.Add(member);
}
internal MethodData(IMethodSymbol methodSymbol, DeclaringTypeData declaringType)
: base(methodSymbol, declaringType)
{
if (methodSymbol.IsGenericMethod)
{
// TODO: This seems odd
MemberDataBase declaringMember = null;
if (!methodSymbol.ContainingType.IsConstructed())
{
declaringMember = this;
}
GenericParameters = Utilities.GetGenericParameters(methodSymbol.TypeParameters, declaringMember);
}
else
{
GenericParameters = GenericTypeParameterData.EmptyList;
}
IsExtensionMethod = methodSymbol.IsExtensionMethod;
}
internal override bool IsEquivalentToNewMember(MemberDataBase newMember, AssemblyFamily newAssemblyFamily)
{
if (base.IsEquivalentToNewMember(newMember, newAssemblyFamily) == false)
{
return(false);
}
var newGenericParameter = (GenericTypeParameterData)newMember;
if (GenericParameterPosition != newGenericParameter.GenericParameterPosition)
{
return(false);
}
if (GenericDeclaringMember.MetadataItemKind == MetadataItemKinds.Method &&
newGenericParameter.GenericDeclaringMember.MetadataItemKind == MetadataItemKinds.Method)
{
// We will get in here recursively for generic methods that take one of their own generic parameters as a parameter
// because the method will check to see whether its parameters are equivalent. All other things being equal, we don't
// need to recheck that the methods are equal here (and if we do, we will end up with a SOE). If the methods are
// otherwise equal, so are these parameters because they came from the same method and had the same position.
// If the methods are not, neither are the parameters.
if (_isInIsEquivalentToNewMember)
{
return(true);
}
try
{
_isInIsEquivalentToNewMember = true;
return(GenericDeclaringMember.IsEquivalentToNewMember(newGenericParameter.GenericDeclaringMember, newAssemblyFamily));
}
finally
{
_isInIsEquivalentToNewMember = false;
}
}
return(GenericDeclaringMember.IsEquivalentToNewMember(newGenericParameter.GenericDeclaringMember, newAssemblyFamily));
}
private MethodData(MethodDefinition methodDefinition, MemberAccessibility accessibility, DeclaringTypeData declaringType)
: base(methodDefinition, accessibility, declaringType)
{
if (methodDefinition.HasGenericParameters)
{
MemberDataBase declaringMember = null;
if (methodDefinition.DeclaringType.IsGenericInstance == false)
{
declaringMember = this;
}
this.GenericParameters = Utilities.GetGenericParameters(methodDefinition.GenericParameters, declaringMember);
}
else
{
this.GenericParameters = GenericTypeParameterData.EmptyList;
}
this.IsExtensionMethod =
declaringType.IsExtensionsClass &&
methodDefinition.CustomAttributes.Any(a => a.AttributeType.EqualsType(typeof(ExtensionAttribute)));
}
/// <summary>
/// Adds the specified member to the declaring type.
/// </summary>
#endif
internal void AddMember(MemberDataBase member)
{
if (member == null)
{
return;
}
if (member.Accessibility == MemberAccessibility.Protected && this.IsSealed)
{
return;
}
List <MemberDataBase> members;
if (_membersByName.TryGetValue(member.Name, out members) == false)
{
members = new List <MemberDataBase>();
_membersByName[member.Name] = members;
}
members.Add(member);
}
/// <inheritdoc/>
internal override bool CanOverrideMember(MemberDataBase baseMember)
{
if (base.CanOverrideMember(baseMember) == false)
{
return(false);
}
var basePropertyData = (PropertyData)baseMember;
// Overrides cannot add accessors
if (GetMethodAccessibility != null && basePropertyData.GetMethodAccessibility == null)
{
return(false);
}
if (SetMethodAccessibility != null && basePropertyData.SetMethodAccessibility == null)
{
return(false);
}
// Overrides cannot change the accessibility of accessors
if (GetMethodAccessibility != null &&
basePropertyData.GetMethodAccessibility != null &&
GetMethodAccessibility != basePropertyData.GetMethodAccessibility)
{
return(false);
}
if (SetMethodAccessibility != null &&
basePropertyData.SetMethodAccessibility != null &&
SetMethodAccessibility != basePropertyData.SetMethodAccessibility)
{
return(false);
}
return(true);
}
/// <summary>
/// Indicates whether a new member of the same type and name is logically the same member as the current member, just from a newer build.
/// </summary>
#endif
internal override bool IsEquivalentToNewMember(MemberDataBase newMember, AssemblyFamily newAssemblyFamily)
{
return(this.IsEquivalentToNewMember((MethodDataBase)newMember, newAssemblyFamily, ignoreNewOptionalParameters: false));
}
bool IParameterizedItem.IsEquivalentToNewMember(MemberDataBase newMember, AssemblyFamily newAssemblyFamily, bool ignoreNewOptionalParameters)
{
return(this.IsEquivalentToNewTypeHelper((TypeDefinitionData)newMember, newAssemblyFamily, ignoreNewOptionalParameters));
}
internal ParameterCollection(IEnumerable <IParameterSymbol> parameterSymbols, MemberDataBase declaringMember)
{
foreach (var parameterSymbol in parameterSymbols)
{
Add(new ParameterData(parameterSymbol, declaringMember));
}
}
/// <summary>
/// Indicates whether the current member can override the specified member from a base type.
/// </summary>
/// <param name="baseMember">The member from the base type.</param>
/// <returns>True if the current member can override the base member; False otherwise.</returns>
#endif
internal override bool CanOverrideMember(MemberDataBase baseMember)
{
Debug.Fail("Types cannot be overridden.");
return(false);
}
bool IParameterizedItem.IsEquivalentToNewMember(MemberDataBase newMember, AssemblyFamily newAssemblyFamily, bool ignoreNewOptionalParameters)
{
return(this.IsEquivalentToNewMember((MethodDataBase)newMember, newAssemblyFamily, ignoreNewOptionalParameters));
}
internal ParameterCollection(IEnumerable <ParameterDefinition> underlyingParameters, MemberDataBase declaringMember)
{
_parameters = new List <ParameterData>();
foreach (var parameter in underlyingParameters)
{
this.Add(new ParameterData(parameter, declaringMember));
}
}