private void WriteMemberHeader(MemberDataBase item)
{
_owner._writer.Write((ushort)item.MetadataItemKind);
_owner._writer.Write(item.Name);
_owner._writer.Write((byte)item.Accessibility);
_owner._writer.Write((byte)item.MemberFlags);
}
private static MemberDataBase FindEquivalentMember(MemberDataBase oldMember, DeclaringTypeData newType, AssemblyFamily newAssemblyFamily, bool allowMatchOnNameOnly = true)
{
var newMembers = newType.GetMembers(oldMember.Name);
if (newMembers.Count == 0)
{
return(null);
}
var candidateMembers = newMembers.Where(m => m.MetadataItemKind == oldMember.MetadataItemKind).ToList();
foreach (var newMember in candidateMembers)
{
if (oldMember.IsEquivalentToNewMember(newMember, newAssemblyFamily))
{
return(newMember);
}
}
// TODO: This could match up a new item to multiple old items. This might need to be improved.
// If we didn't find any match and the current member has parameters, we should try to match this method up
// with any new method that has the same required parameters, but new optional parameters as well.
var oldParameterizedMember = oldMember as IParameterizedItem;
if (oldParameterizedMember != null)
{
foreach (var newParameterizedMember in candidateMembers)
{
if (oldParameterizedMember.IsEquivalentToNewMember(newParameterizedMember, newAssemblyFamily, ignoreNewOptionalParameters: true))
{
return((MemberDataBase)newParameterizedMember);
}
}
}
// If there is only one member, we may still want to return it (for example, if both types have a single method with the same name but
// a different number of parameters, they are incompatible for normal comparison, but not since there is only one method in both versions
// we can safely assume they are the "same" and report errors for the number or types of parameters changing.
if (allowMatchOnNameOnly &&
candidateMembers.Count == 1 &&
oldMember.DeclaringType.GetMembers(oldMember.Name).Count == 1)
{
switch (oldMember.MetadataItemKind)
{
case MetadataItemKinds.Constant:
case MetadataItemKinds.Constructor:
case MetadataItemKinds.Event:
case MetadataItemKinds.Field:
case MetadataItemKinds.Indexer:
case MetadataItemKinds.Method:
case MetadataItemKinds.Operator:
case MetadataItemKinds.Property:
case MetadataItemKinds.TypeDefinition:
return(candidateMembers[0]);
}
}
return(null);
}
private static string GetFullMemberName(MemberDataBase member)
{
if (member.MetadataItemKind == MetadataItemKinds.TypeDefinition)
{
return(member.DisplayName);
}
return(member.DeclaringType.DisplayName + "." + member.DisplayName);
}
public static bool CanWrite(this MemberDataBase propertyFieldOrConstant)
{
switch (propertyFieldOrConstant.MetadataItemKind)
{
case MetadataItemKinds.Constant: return(false);
case MetadataItemKinds.Field: return(((FieldData)propertyFieldOrConstant).IsReadOnly == false);
case MetadataItemKinds.Property: return(((PropertyData)propertyFieldOrConstant).SetMethodAccessibility != null);
default:
Debug.Fail("Unknown MetadataItemKinds: " + propertyFieldOrConstant.MetadataItemKind);
return(false);
}
}
private static bool IsMemberKindChangeAllowed(MemberDataBase oldMember, TypeDefinitionData newType, AssemblyFamily newAssemblyFamily)
{
if (oldMember.MetadataItemKind == MetadataItemKinds.Constant ||
(oldMember.MetadataItemKind == MetadataItemKinds.Field && ((FieldData)oldMember).IsReadOnly) ||
(oldMember.MetadataItemKind == MetadataItemKinds.Property && oldMember.CanBeOverridden == false))
{
var oldTypedMemer = (TypedMemberDataBase)oldMember;
var candidateMembers = newType.GetMembers(oldMember.Name).Where(m =>
(
m.MetadataItemKind == MetadataItemKinds.Constant ||
m.MetadataItemKind == MetadataItemKinds.Field ||
m.MetadataItemKind == MetadataItemKinds.Property
) &&
oldTypedMemer.Accessibility <= m.Accessibility &&
m.IsInstance == oldMember.IsInstance &&
oldTypedMemer.Type.IsEquivalentToNew(((ITypedItem)m).Type, newAssemblyFamily)
).ToList();
if (candidateMembers.Count == 0)
{
return(false);
}
Debug.Assert(candidateMembers.Count == 1, "There should only be one member with the same name.");
var newMember = candidateMembers[0];
if (oldMember.CanRead() && newMember.CanRead() == false)
{
return(false);
}
if (oldMember.CanWrite() && newMember.CanWrite() == false)
{
return(false);
}
var newProperty = newMember as PropertyData;
if (newProperty != null && newProperty.GetMethodAccessibility < oldMember.Accessibility)
{
return(false);
}
return(true);
}
return(false);
}
private static MemberDataBase FindEquivalentMemberInClassHierarchy(MemberDataBase oldMember, DeclaringTypeData newType, AssemblyFamily newAssemblyFamily)
{
var allowMatchOnNameOnly = true;
var current = newType;
while (current != null)
{
var newMember = FindEquivalentMember(oldMember, current, newAssemblyFamily, allowMatchOnNameOnly);
if (newMember != null)
{
return(newMember);
}
current = current.BaseType;
allowMatchOnNameOnly = false;
}
return(null);
}
private static IEnumerable <BreakingChangeBase> CompareMembers(MemberDataBase oldMember, MemberDataBase newMember, AssemblyFamily newAssemblyFamily)
{
switch (oldMember.MetadataItemKind)
{
case MetadataItemKinds.Constant:
case MetadataItemKinds.Event:
case MetadataItemKinds.Field:
case MetadataItemKinds.Property:
return(CompareItems(oldMember, newMember, newAssemblyFamily));
case MetadataItemKinds.Indexer:
return(CompareIndexers((IndexerData)oldMember, (IndexerData)newMember, newAssemblyFamily));
case MetadataItemKinds.Constructor:
case MetadataItemKinds.Operator:
{
var breakingChanges = CompareItems(oldMember, newMember, newAssemblyFamily);
CompareParameters((IParameterizedItem)oldMember, (IParameterizedItem)newMember, newAssemblyFamily, breakingChanges);
return(breakingChanges);
}
case MetadataItemKinds.Method:
return(CompareMethods((MethodData)oldMember, (MethodData)newMember, newAssemblyFamily));
case MetadataItemKinds.TypeDefinition:
return(CompareTypes((TypeDefinitionData)oldMember, (TypeDefinitionData)newMember, newAssemblyFamily));
case MetadataItemKinds.Assembly:
case MetadataItemKinds.GenericTypeParameter:
case MetadataItemKinds.Parameter:
Debug.Fail("This is not a member: " + oldMember.MetadataItemKind);
break;
default:
Debug.Fail("Unknown MetadataItemKinds: " + oldMember.MetadataItemKind);
break;
}
return(_noBreakingChanges);
}
internal AddedAbstractMember(MemberDataBase newMember)
: base(null, newMember, null, BreakingChangeKind.AddedAbstractMember)
{
NewMember = newMember;
}
public static GenericTypeParameterCollection GetGenericParameters(INamedTypeSymbol namedTypeSymbol, MemberDataBase declaringMember)
{
// TODO_Refactor: Since Roslyn requires this but Mono.Cecil did not, perhaps we can redesign things so we don't have to do this.
IEnumerable <ITypeParameterSymbol> allGenericParameters = namedTypeSymbol.TypeParameters;
while (true)
{
namedTypeSymbol = namedTypeSymbol.ContainingType;
if (namedTypeSymbol == null)
{
break;
}
if (!namedTypeSymbol.TypeParameters.IsEmpty)
{
allGenericParameters = namedTypeSymbol.TypeParameters.Concat(allGenericParameters);
}
}
return(GetGenericParameters(allGenericParameters, declaringMember));
}
/// <summary>
/// Creates a <see cref="FormatItem"/> to represent the C# name of a <see cref="MemberDataBase"/> with the specified formatting.
/// </summary>
public static FormatItem MemberKind(MemberDataBase member, StyleFlags style = StyleFlags.Normal)
{
return(new FormatItem(GetItemDescription(member), style));
}
internal ChangedStaticOrInstanceStatus(MemberDataBase oldMember, MemberDataBase newMember)
: base(oldMember, newMember, null, BreakingChangeKind.ChangedStaticOrInstanceStatus)
{
OldMember = oldMember;
NewMember = newMember;
}
internal ChangedMemberToNonVirtual(MemberDataBase oldMember, MemberDataBase newMember)
: base(oldMember, newMember, null, BreakingChangeKind.ChangedMemberToNonVirtual)
{
OldMember = oldMember;
NewMember = newMember;
}
internal ChangedMemberToAbstract(MemberDataBase oldMember, MemberDataBase newMember)
: base(oldMember, newMember, null, BreakingChangeKind.ChangedMemberToAbstract)
{
OldMember = oldMember;
NewMember = newMember;
}
internal ChangedAccessibilityFromPublicToProtected(MemberDataBase oldMember, MemberDataBase newMember)
: base(oldMember, newMember, null, BreakingChangeKind.ChangedAccessibilityFromPublicToProtected)
{
OldMember = oldMember;
NewMember = newMember;
}
internal SealedMember(MemberDataBase oldMember, MemberDataBase newMember)
: base(oldMember, newMember, null, BreakingChangeKind.SealedMember)
{
OldMember = oldMember;
NewMember = newMember;
}
public static GenericTypeParameterCollection GetGenericParameters(IEnumerable <ITypeParameterSymbol> typeParameterSymbols, MemberDataBase declaringMember)
{
return(new GenericTypeParameterCollection(typeParameterSymbols.Select(typeParameterSymbol =>
{
var genericParameter = declaringMember.Context.GetGenericTypeParameterData(typeParameterSymbol);
if (declaringMember != null) // TODO: Is this needed?
{
// TODO_Refactor: If non-null, assert it is a containing type
//Debug.Assert(genericParameter.GenericDeclaringMember == null, "The GenericDeclaringMember should not be set twice.");
if (genericParameter.GenericDeclaringMember == null)
{
genericParameter.GenericDeclaringMember = declaringMember;
}
}
return genericParameter;
})));
}
internal RemovedMember(MemberDataBase oldMember, TypeDefinitionData newType)
: base(oldMember, null, newType, BreakingChangeKind.RemovedMember)
{
NewType = newType;
OldMember = oldMember;
}
internal RemovedOverrideOfAbstractMember(MemberDataBase oldMemberOverride, TypeDefinitionData newType)
: base(oldMemberOverride, null, newType, BreakingChangeKind.RemovedOverrideOfAbstractMember)
{
NewType = newType;
OldMemberOverride = oldMemberOverride;
}
/// <summary>
/// Creates a <see cref="FormatItem"/> to represent the full name of a <see cref="MemberDataBase"/> with the specified formatting.
/// </summary>
public static FormatItem MemberName(MemberDataBase member, StyleFlags style = StyleFlags.Normal)
{
return(new FormatItem(GetFullMemberName(member), style));
}
public static GenericTypeParameterCollection GetGenericParameters(IEnumerable <GenericParameter> genericArguments, MemberDataBase declaringMember)
{
return(new GenericTypeParameterCollection(genericArguments.Select(a =>
{
var genericParameter = GenericTypeParameterData.FromType(a);
if (declaringMember != null)
{
Debug.Assert(genericParameter.GenericDeclaringMember == null, "The GenericDeclaringMember should not be set twice.");
genericParameter.GenericDeclaringMember = declaringMember;
}
return genericParameter;
})));
}
