public override DifferenceType Diff(IDifferences differences, Mappings.MemberMapping mapping)
{
ITypeDefinitionMember impl = mapping[0];
ITypeDefinitionMember contract = mapping[1];
if (impl == null)
{
return(DifferenceType.Unknown);
}
if (contract == null && impl.IsAbstract())
{
// If the type is effectively sealed then it is ok to remove abstract members
ITypeDefinition contractType = mapping.ContainingType[1];
// We check that interfaces have the same number of members in another rule so there is no need to check that here.
if (contractType != null && (contractType.IsEffectivelySealed() || (contractType.IsInterface && mapping.ContainingType[0].IsInterface)))
{
return(DifferenceType.Unknown);
}
differences.AddIncompatibleDifference(this, impl.GetMemberViolationMessage("Member", $"is abstract in the {Implementation}", $"is missing in the {Contract}"));
return(DifferenceType.Changed);
}
return(DifferenceType.Unknown);
}
public virtual bool Include(ITypeDefinitionMember member)
{
switch (member.Visibility)
{
case TypeMemberVisibility.Public:
return(true);
case TypeMemberVisibility.Family:
case TypeMemberVisibility.FamilyOrAssembly:
// CCI's version of IsVisibleOutsideAssembly doesn't
// consider protected members as being visible but for
// our purposes which is to write CS files that can
// be compiled we always need the protected members
return(true);
}
if (!member.IsVisibleOutsideAssembly())
{
// If a type is public, abstract and has a public constructor,
// then it must expose all abstract members.
if (member.ContainingTypeDefinition.IsAbstract &&
member.IsAbstract() &&
member.ContainingTypeDefinition.IsConstructorVisible()
)
{
return(true);
}
return(false);
}
return(true);
}
public virtual bool Include(ITypeDefinitionMember member)
{
// Include internal and private protected members.
if (member.Visibility == TypeMemberVisibility.Family ||
member.Visibility == TypeMemberVisibility.FamilyAndAssembly)
{
// Similar to special case in PublicOnlyCciFilter, include protected members even of a sealed type.
// This is necessary to generate compilable code e.g. callers with IVT dependencies on this assembly
// may call internal methods in a sealed type. (IsVisibleToFriendAssemblies() includes the IsSealed
// check for other use cases besides this one.)
return(true);
}
// Include public(-ish) members and explicit interface implementations.
if (member.IsVisibleToFriendAssemblies())
{
return(true);
}
// If a type is abstract and has an internal or public constructor, it must expose all abstract members.
var containingType = member.ContainingTypeDefinition;
if (containingType.IsAbstract &&
member.IsAbstract() &&
containingType.IsConstructorVisibleToFriendAssemblies())
{
return(true);
}
// Otherwise...
return(false);
}
public override DifferenceType Diff(IDifferences differences, ITypeDefinitionMember impl, ITypeDefinitionMember contract)
{
if (impl == null || contract == null)
{
return(DifferenceType.Unknown);
}
if (impl.IsAbstract() && !contract.IsAbstract())
{
differences.AddIncompatibleDifference("CannotMakeMemberAbstract", impl.GetMemberViolationMessage("Member", $"is abstract in the {Implementation}", $"is not abstract in the {Contract}"));
return(DifferenceType.Changed);
}
return(DifferenceType.Unknown);
}
public override DifferenceType Diff(IDifferences differences, ITypeDefinitionMember impl, ITypeDefinitionMember contract)
{
if (impl == null || contract == null)
return DifferenceType.Unknown;
if (impl.IsAbstract() && !contract.IsAbstract())
{
differences.AddIncompatibleDifference("CannotMakeMemberAbstract",
"Member '{0}' is abstract in the implementation but is not abstract in the contract.",
impl.FullName());
return DifferenceType.Changed;
}
return DifferenceType.Unknown;
}
public override DifferenceType Diff(IDifferences differences, ITypeDefinitionMember impl, ITypeDefinitionMember contract)
{
if (impl == null || contract == null)
{
return(DifferenceType.Unknown);
}
if (impl.IsAbstract() && !contract.IsAbstract())
{
differences.AddIncompatibleDifference("CannotMakeMemberAbstract",
$"Member '{impl.FullName()}' is abstract in the {Implementation} but is not abstract in the {Contract}.");
return(DifferenceType.Changed);
}
return(DifferenceType.Unknown);
}