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; }))); }