public IEnumerable <SemverRuleResult> Inspect(ApiMemberInfo prior, ApiMemberInfo current)
{
if (prior == null || current == null)
{
yield break;
}
if (!(prior is ApiEventInfo priorEvent) || !(current is ApiEventInfo currentEvent))
{
yield break;
}
if (!priorEvent.GetModifiers().SequenceEqual(currentEvent.GetModifiers()))
{
yield return(new SemverRuleResult("Modifiers changed", "The modifiers of this event were changed", SemverChangeType.Major));
}
var priorTypeDetail = priorEvent.GetEventType();
var currentTypeDetail = currentEvent.GetEventType();
if (priorTypeDetail.Type.Name != currentTypeDetail.Type.Name)
{
yield return(new SemverRuleResult("Type changed", "The type of this event was changed", SemverChangeType.Major));
}
else if (priorTypeDetail.ReferenceNullabilityHash != currentTypeDetail.ReferenceNullabilityHash)
{
yield return(new SemverRuleResult($"Nullability changed", "The reference nullability of this event was changed", SemverChangeType.Patch));
}
}
public IEnumerable <SemverRuleResult> Inspect(ApiMemberInfo prior, ApiMemberInfo current)
{
if (prior == null && current != null)
{
yield return(newMemberResult);
}
}
public IEnumerable <SemverRuleResult> Inspect(ApiMemberInfo prior, ApiMemberInfo current)
{
if (current == null && prior != null)
{
yield return(removedResult);
}
}
public IEnumerable <SemverRuleResult> InspectRules(ApiMemberInfo prior, ApiMemberInfo current)
{
foreach (var rule in Rules)
{
foreach (var ruleResult in rule.Inspect(prior, current))
{
yield return(ruleResult);
}
}
}
public static ApiMemberInfo Describe(this ResolvedMethod src)
{
var dst = new ApiMemberInfo();
var msil = ClrDynamic.msil(src.EntryPoint, src.Uri, src.Method);
dst.EntryPoint = src.EntryPoint;
dst.ApiKind = src.Method.KindId();
dst.CliSig = msil.CliSig;
dst.DisplaySig = src.Method.DisplaySig().Format();
dst.Token = msil.Token;
dst.Uri = src.Uri.Format();
dst.MsilCode = msil.Code;
return(dst);
}
public IEnumerable <SemverRuleResult> Inspect(ApiMemberInfo prior, ApiMemberInfo current)
{
if (prior == null || current == null)
{
yield break;
}
if (!(prior is ApiPropertyInfo priorProperty) || !(current is ApiPropertyInfo currentProperty))
{
yield break;
}
if (priorProperty.HasGetter && !currentProperty.HasGetter)
{
yield return(new SemverRuleResult("Getter removed", "The get accessor was removed from this property", SemverChangeType.Major));
}
else if (currentProperty.HasGetter && !priorProperty.HasGetter)
{
yield return(new SemverRuleResult("Getter added", "A get accessor was added to this property", SemverChangeType.Minor));
}
if (priorProperty.HasSetter && !currentProperty.HasSetter)
{
yield return(new SemverRuleResult("Setter removed", "The set accessor was removed from this property", SemverChangeType.Major));
}
else if (currentProperty.HasSetter && !priorProperty.HasSetter)
{
yield return(new SemverRuleResult("Setter added", "A set accessor was added to this property", SemverChangeType.Minor));
}
if (!priorProperty.GetModifiers().SequenceEqual(currentProperty.GetModifiers()))
{
yield return(new SemverRuleResult("Modifiers changed", "The modifiers of this property were changed", SemverChangeType.Major));
}
var priorTypeDetail = priorProperty.GetPropertyType();
var currentTypeDetail = currentProperty.GetPropertyType();
if (priorTypeDetail.Type.Name != currentTypeDetail.Type.Name)
{
yield return(new SemverRuleResult("Type changed", "The type of this property was changed", SemverChangeType.Major));
}
else if (priorTypeDetail.ReferenceNullabilityHash != currentTypeDetail.ReferenceNullabilityHash)
{
yield return(new SemverRuleResult($"Nullability changed", "The reference nullability of this property was changed", SemverChangeType.Patch));
}
}
public IEnumerable <SemverRuleResult> Inspect(ApiMemberInfo prior, ApiMemberInfo current)
{
if (prior == null || current == null)
{
yield break;
}
if (!(prior is ApiConstructorInfo priorConstructor) || !(current is ApiConstructorInfo currentConstructor))
{
yield break;
}
var modifiersEqual = priorConstructor.GetModifiers().SequenceEqual(currentConstructor.GetModifiers());
if (!modifiersEqual)
{
yield return(new SemverRuleResult("Modifiers changed", "The modifiers of this constructor changed", SemverChangeType.Major));
}
var priorParams = priorConstructor.GetParameters();
var currentParams = currentConstructor.GetParameters();
if (priorParams.Count() > currentParams.Count())
{
yield return(new SemverRuleResult("Parameters removed", "Parameters were removed from this constructor.", SemverChangeType.Major));
}
else if (priorParams.Count() < currentParams.Count())
{
yield return(new SemverRuleResult("Parameters added", "New parameters were added to this constructor.", SemverChangeType.Major));
}
else
{
var counter = 0;
foreach (var(param1, param2) in priorParams.Zip(currentParams))
{
counter++;
if (param1.Type.Name != param2.Type.Name)
{
yield return(new SemverRuleResult($"Parameter {counter} type changed", $"The type of parameter {counter} was changed.", SemverChangeType.Major));
}
else if (param1.HasDefaultValue && !param2.HasDefaultValue)
{
yield return(new SemverRuleResult($"Parameter {counter} is no longer optional", $"Parameter {counter} was changed to no longer have a default value.", SemverChangeType.Major));
}
else if (!param1.HasDefaultValue && param2.HasDefaultValue)
{
yield return(new SemverRuleResult($"Parameter {counter} is now optional", $"Parameter {counter} was changed to be optional.", SemverChangeType.Minor));
}
else if (param1.DefaultValue != param2.DefaultValue)
{
yield return(new SemverRuleResult($"Parameter {counter} default value changed", $"The default value of parameter {counter} was changed.", SemverChangeType.Minor));
}
else if (param1.ReferenceNullabilityHash != param2.ReferenceNullabilityHash)
{
yield return(new SemverRuleResult($"Parameter {counter} nullability changed", $"The reference nullability of parameter {counter} was changed.", SemverChangeType.Patch));
}
else if (param1.Name != param2.Name)
{
yield return(new SemverRuleResult($"Parameter {counter} name changed", $"The name of parameter {counter} was changed.", SemverChangeType.Minor));
}
}
}
}
public IEnumerable <SemverRuleResult> Inspect(ApiMemberInfo prior, ApiMemberInfo current)
{
if (prior == null || current == null)
{
yield break;
}
if (!(prior is ApiTypeInfo priorType) || !(current is ApiTypeInfo currentType))
{
yield break;
}
var modifiersEqual = priorType.GetModifiers().SequenceEqual(currentType.GetModifiers());
if (!modifiersEqual)
{
yield return(new SemverRuleResult("Modifiers changed", "The modifiers of this type were changed", SemverChangeType.Major));
}
if (!priorType.GetInterfaces().SequenceEqual(currentType.GetInterfaces()))
{
if (modifiersEqual && currentType.GetModifiers().Contains("sealed"))
{
yield return(new SemverRuleResult("Interfaces changed on a sealed class", "The implemented interfaces of this sealed type were changed", SemverChangeType.Patch));
}
else
{
yield return(new SemverRuleResult("Interfaces changed", "The implemented interfaces of this type were changed", SemverChangeType.Major));
}
}
if (!priorType.GetBaseType()?.Equals(currentType.GetBaseType()) ?? false)
{
yield return(new SemverRuleResult("Base type changed", "The base type for this derived type was changed.", SemverChangeType.Major));
}
var priorArgs = priorType.GetGenericArgs();
var currentArgs = currentType.GetGenericArgs();
if (priorArgs.Count() > currentArgs.Count())
{
yield return(new SemverRuleResult("Generic arguments removed", "Generic arguments were removed from this type.", SemverChangeType.Major));
}
else if (priorArgs.Count() < currentArgs.Count())
{
yield return(new SemverRuleResult("Parameters added", "Generic arguments were added to this type.", SemverChangeType.Major));
}
else
{
var counter = 0;
foreach (var(param1, param2) in priorArgs.Zip(currentArgs))
{
counter++;
if (param1.Type.Name != param2.Type.Name)
{
yield return(new SemverRuleResult($"Generic argument {counter} type changed", $"The type of argument {counter} was changed.", SemverChangeType.Major));
}
else if (param1.ReferenceNullabilityHash != param2.ReferenceNullabilityHash)
{
yield return(new SemverRuleResult($"Generic argument {counter} nullability changed", $"The reference nullability of argument {counter} was changed.", SemverChangeType.Patch));
}
}
}
var priorConstraints = priorType.GetConstraints();
var currentConstraints = currentType.GetConstraints();
if (!priorConstraints.SequenceEqual(currentConstraints))
{
yield return(new SemverRuleResult("Constraints changed", "The generic argument constraints for this type were changed", SemverChangeType.Major));
}
}
