// <Name>Avoid empty interfaces</Name>
warnif count > 0 from t in JustMyCode.Types where 
   
t.IsInterface && 
   
t.NbMethods == 0
select new { 
   
t, 
   
t.TypesThatImplementMe,
   
Debt = (10 + 3*t.TypesThatImplementMe.Count()).ToMinutes().ToDebt(),
   
Severity = t.TypesThatImplementMe.Any() ? Severity.Minor : Severity.Info
}

//<Description>
// Interfaces define members that provide 
// a behavior or usage contract. 
// The functionality that is described by the interface 
// can be adopted by any type, regardless of where the type 
// appears in the inheritance hierarchy. 
// A type implements an interface by providing implementations 
// for the members of the interface. 
// An empty interface does not define any members. 
// Therefore, it does not define a contract that can be implemented.
//
// If your design includes empty interfaces that types 
// are expected to implement, you are probably using an interface 
// as a marker or a way to identify a group of types. 
// If this identification will occur at run time, 
// the correct way to accomplish this is to use a custom attribute. 
// Use the presence or absence of the attribute, 
// or the properties of the attribute, to identify the target types. 
// If the identification must occur at compile time, 
// then it is acceptable to use an empty interface.
//</Description>

//<HowToFix>
// Remove the interface or add members to it. 
// If the empty interface is being used to label a set of types, 
// replace the interface with a custom attribute.
//
// The estimated Debt, which means the effort to fix such issue,
// is equal to 10 minutes to discard an empty interface plus
// 3 minutes per type implementing an empty interface.
//</HowToFix>