//private bool AnySecurityAttributeAdded(IDifferences differences, IReference target, IEnumerable<ISecurityAttribute> attribues1, IEnumerable<ISecurityAttribute> attributes2) //{ // return AnyAttributeAdded(differences, target, attribues1.SelectMany(a => a.Attributes), attributes2.SelectMany(a => a.Attributes)); //} private void CheckAttributeDifferences(IDifferences differences, IReference target, IEnumerable <ICustomAttribute> implAttributes, IEnumerable <ICustomAttribute> contractAttributes) { AttributesMapping <IEnumerable <ICustomAttribute> > attributeMapping = new AttributesMapping <IEnumerable <ICustomAttribute> >(_settings); attributeMapping.AddMapping(0, contractAttributes); attributeMapping.AddMapping(1, implAttributes); foreach (var group in attributeMapping.Attributes) { switch (group.Difference) { case DifferenceType.Added: { ITypeReference type = group.Representative.Attributes.First().Type; string attribName = type.FullName(); if (FilterAttribute(attribName)) { break; } AttributeAdded(target, attribName); differences.AddIncompatibleDifference("CannotAddAttribute", "Attribute '{0}' exists on '{1}' in the implementation but not the contract.", attribName, target.FullName()); break; } case DifferenceType.Changed: //TODO: Add some more logic to check the two lists of attributes which have the same type. break; case DifferenceType.Removed: { ITypeReference type = group.Representative.Attributes.First().Type; string attribName = type.FullName(); if (s_IgnorableAttributes.Contains(attribName)) { break; } differences.AddIncompatibleDifference("CannotRemoveAttribute", "Attribute '{0}' exists on '{1}' in the contract but not the implementation.", attribName, target.FullName()); break; } } } }
private DifferenceType DiffConstraints(IDifferences differences, IReference target, IEnumerable <IGenericParameter> implGenericParams, IEnumerable <IGenericParameter> contractGenericParams) { int beforeCount = differences.Count(); IGenericParameter[] implParams = implGenericParams.ToArray(); IGenericParameter[] contractParams = contractGenericParams.ToArray(); // We shoudn't hit this because the types/members shouldn't be matched up if they have different generic argument lists if (implParams.Length != contractParams.Length) { return(DifferenceType.Changed); } for (int i = 0; i < implParams.Length; i++) { IGenericParameter implParam = implParams[i]; IGenericParameter contractParam = contractParams[i]; if (contractParam.Variance != TypeParameterVariance.NonVariant && contractParam.Variance != implParam.Variance) { differences.AddIncompatibleDifference("CannotChangeVariance", "Variance on generic parameter '{0}' for '{1}' is '{2}' in the implementation but '{3}' in the contract.", implParam.FullName(), target.FullName(), implParam.Variance, contractParam.Variance); } string implConstraints = string.Join(",", GetConstraints(implParam).OrderBy(s => s, StringComparer.OrdinalIgnoreCase)); string contractConstraints = string.Join(",", GetConstraints(contractParam).OrderBy(s => s, StringComparer.OrdinalIgnoreCase)); if (!string.Equals(implConstraints, contractConstraints)) { differences.AddIncompatibleDifference("CannotChangeGenericConstraints", "Constraints for generic parameter '{0}' for '{1}' is '{2}' in the implementation but '{3}' in the contract.", implParam.FullName(), target.FullName(), implConstraints, contractConstraints); } } if (differences.Count() != beforeCount) { return(DifferenceType.Changed); } return(DifferenceType.Unknown); }
private DifferenceType DiffConstraints(IDifferences differences, IReference target, IEnumerable<IGenericParameter> implGenericParams, IEnumerable<IGenericParameter> contractGenericParams) { int beforeCount = differences.Count(); IGenericParameter[] implParams = implGenericParams.ToArray(); IGenericParameter[] contractParams = contractGenericParams.ToArray(); // We shoudn't hit this because the types/members shouldn't be matched up if they have different generic argument lists if (implParams.Length != contractParams.Length) return DifferenceType.Changed; for (int i = 0; i < implParams.Length; i++) { IGenericParameter implParam = implParams[i]; IGenericParameter contractParam = contractParams[i]; if (contractParam.Variance != TypeParameterVariance.NonVariant && contractParam.Variance != implParam.Variance) { differences.AddIncompatibleDifference("CannotChangeVariance", "Variance on generic parameter '{0}' for '{1}' is '{2}' in the implementation but '{3}' in the contract.", implParam.FullName(), target.FullName(), implParam.Variance, contractParam.Variance); } string implConstraints = string.Join(",", GetConstraints(implParam).OrderBy(s => s)); string contractConstraints = string.Join(",", GetConstraints(contractParam).OrderBy(s => s)); if (!string.Equals(implConstraints, contractConstraints)) { differences.AddIncompatibleDifference("CannotChangeGenericConstraints", "Constraints for generic parameter '{0}' for '{1}' is '{2}' in the implementation but '{3}' in the contract.", implParam.FullName(), target.FullName(), implConstraints, contractConstraints); } } if (differences.Count() != beforeCount) return DifferenceType.Changed; return DifferenceType.Unknown; }
private bool AnyAttributeAdded(IDifferences differences, IReference target, IEnumerable <ICustomAttribute> implAttributes, IEnumerable <ICustomAttribute> contractAttributes) { bool added = false; AttributesMapping <IEnumerable <ICustomAttribute> > attributeMapping = new AttributesMapping <IEnumerable <ICustomAttribute> >(_settings); attributeMapping.AddMapping(0, implAttributes); attributeMapping.AddMapping(1, contractAttributes); foreach (var group in attributeMapping.Attributes) { switch (group.Difference) { case DifferenceType.Added: ITypeReference type = group.Representative.Attributes.First().Type; string attribName = type.FullName(); if (s_IgnorableAttributes.Contains(attribName)) { break; } differences.AddIncompatibleDifference(this, "Attribute '{0}' exists in the contract but not the implementation.", attribName, target.FullName()); added = true; break; case DifferenceType.Changed: //TODO: Add some more logic to check the two lists of attributes which have the same type. break; case DifferenceType.Removed: // Removing attributes is OK break; } } return(added); }
private static bool Exclude(IReference reference, HashSet <string> exclusions, string alternateName = null) { string name = reference.FullName(); bool excluded = exclusions.Contains(name); if (!excluded && alternateName != null) { excluded = exclusions.Contains(alternateName); } bool exclude = excluded || (reference.Attributes != null && reference.Attributes.Any(attribute => attribute.IsEditorBrowseableStateNever())); if (exclude && !excluded) { exclusions.Add(name); } return(exclude); }
private static bool Exclude(IReference reference, HashSet<string> exclusions, string alternateName = null) { string name = reference.FullName(); bool excluded = exclusions.Contains(name); if (!excluded && alternateName != null) { excluded = exclusions.Contains(alternateName); } bool exclude = excluded || (reference.Attributes != null && reference.Attributes.Any(attribute => attribute.IsEditorBrowseableStateNever())); if (exclude && !excluded) { exclusions.Add(name); } return exclude; }
private DifferenceType CheckAttributeDifferences(IDifferences differences, IReference target, IEnumerable <ICustomAttribute> implAttributes, IEnumerable <ICustomAttribute> contractAttributes) { DifferenceType difference = DifferenceType.Unchanged; AttributesMapping <IEnumerable <ICustomAttribute> > attributeMapping = new AttributesMapping <IEnumerable <ICustomAttribute> >(_settings); AttributeComparer attributeComparer = new AttributeComparer(); attributeMapping.AddMapping(0, contractAttributes.OrderBy(a => a, attributeComparer)); attributeMapping.AddMapping(1, implAttributes.OrderBy(a => a, attributeComparer)); foreach (var group in attributeMapping.Attributes) { switch (group.Difference) { case DifferenceType.Added: { ITypeReference type = group.Representative.Attributes.First().Type; if (AttributeFilter.ShouldExclude(type.DocId())) { break; } // Allow for additions differences.Add(new Difference("AddedAttribute", $"Attribute '{type.FullName()}' exists on '{target.FullName()}' in the {Implementation} but not the {Contract}.")); break; } case DifferenceType.Changed: { ITypeReference type = group.Representative.Attributes.First().Type; if (AttributeFilter.ShouldExclude(type.DocId())) { break; } string contractKey = attributeComparer.GetKey(group[0].Attributes.First()); string implementationKey = attributeComparer.GetKey(group[1].Attributes.First()); differences.AddIncompatibleDifference("CannotChangeAttribute", $"Attribute '{type.FullName()}' on '{target.FullName()}' changed from '{contractKey}' in the {Contract} to '{implementationKey}' in the {Implementation}."); difference = DifferenceType.Changed; break; } case DifferenceType.Removed: { ITypeReference type = group.Representative.Attributes.First().Type; if (AttributeFilter.ShouldExclude(type.DocId())) { break; } differences.AddIncompatibleDifference("CannotRemoveAttribute", $"Attribute '{type.FullName()}' exists on '{target.FullName()}' in the {Contract} but not the {Implementation}."); // removals of an attribute are considered a "change" of the type difference = DifferenceType.Changed; break; } } } return(difference); }
private bool CheckAttributeDifferences(IDifferences differences, IReference target, IEnumerable <ICustomAttribute> implAttributes, IEnumerable <ICustomAttribute> contractAttributes, IReference member = null) { AttributesMapping <IEnumerable <ICustomAttribute> > attributeMapping = new AttributesMapping <IEnumerable <ICustomAttribute> >(_settings); AttributeComparer attributeComparer = new AttributeComparer(); attributeMapping.AddMapping(0, contractAttributes.OrderBy(a => a, attributeComparer)); attributeMapping.AddMapping(1, implAttributes.OrderBy(a => a, attributeComparer)); string errString = $"'{target.FullName()}'"; if (target is IParameterDefinition || target is IGenericParameter) { errString = target is IGenericParameter ? "generic param" : "parameter"; errString += $" '{target.FullName()}' on member '{member?.FullName()}'"; } bool changed = false; foreach (var group in attributeMapping.Attributes) { switch (group.Difference) { case DifferenceType.Added: { ITypeReference type = group.Representative.Attributes.First().Type; if (AttributeFilter.ShouldExclude(type.DocId())) { break; } // Allow for additions differences.Add(new Difference("AddedAttribute", $"Attribute '{type.FullName()}' exists on {errString} in the {Implementation} but not the {Contract}.")); changed = true; break; } case DifferenceType.Changed: { ITypeReference type = group.Representative.Attributes.First().Type; if (AttributeFilter.ShouldExclude(type.DocId())) { break; } string contractKey = attributeComparer.GetKey(group[0].Attributes.First()); string implementationKey = attributeComparer.GetKey(group[1].Attributes.First()); differences.AddIncompatibleDifference("CannotChangeAttribute", $"Attribute '{type.FullName()}' on {errString} changed from '{contractKey}' in the {Contract} to '{implementationKey}' in the {Implementation}."); changed = true; break; } case DifferenceType.Removed: { ITypeReference type = group.Representative.Attributes.First().Type; if (AttributeFilter.ShouldExclude(type.DocId())) { break; } differences.AddIncompatibleDifference("CannotRemoveAttribute", $"Attribute '{type.FullName()}' exists on {errString} in the {Contract} but not the {Implementation}."); // removals of an attribute are considered a "change" of the type changed = true; break; } } } return(changed); }
//private bool AnySecurityAttributeAdded(IDifferences differences, IReference target, IEnumerable<ISecurityAttribute> attribues1, IEnumerable<ISecurityAttribute> attributes2) //{ // return AnyAttributeAdded(differences, target, attribues1.SelectMany(a => a.Attributes), attributes2.SelectMany(a => a.Attributes)); //} private void CheckAttributeDifferences(IDifferences differences, IReference target, IEnumerable<ICustomAttribute> implAttributes, IEnumerable<ICustomAttribute> contractAttributes) { AttributesMapping<IEnumerable<ICustomAttribute>> attributeMapping = new AttributesMapping<IEnumerable<ICustomAttribute>>(_settings); attributeMapping.AddMapping(0, contractAttributes); attributeMapping.AddMapping(1, implAttributes); foreach (var group in attributeMapping.Attributes) { switch (group.Difference) { case DifferenceType.Added: { ITypeReference type = group.Representative.Attributes.First().Type; string attribName = type.FullName(); if (FilterAttribute(attribName)) break; AttributeAdded(target, attribName); differences.AddIncompatibleDifference("CannotAddAttribute", "Attribute '{0}' exists on '{1}' in the implementation but not the contract.", attribName, target.FullName()); break; } case DifferenceType.Changed: //TODO: Add some more logic to check the two lists of attributes which have the same type. break; case DifferenceType.Removed: { ITypeReference type = group.Representative.Attributes.First().Type; string attribName = type.FullName(); if (s_IgnorableAttributes.Contains(attribName)) break; differences.AddIncompatibleDifference("CannotRemoveAttribute", "Attribute '{0}' exists on '{1}' in the contract but not the implementation.", attribName, target.FullName()); break; } } } }
private bool AnyAttributeAdded(IDifferences differences, IReference target, IEnumerable<ICustomAttribute> implAttributes, IEnumerable<ICustomAttribute> contractAttributes) { bool added = false; AttributesMapping<IEnumerable<ICustomAttribute>> attributeMapping = new AttributesMapping<IEnumerable<ICustomAttribute>>(_settings); attributeMapping.AddMapping(0, implAttributes); attributeMapping.AddMapping(1, contractAttributes); foreach (var group in attributeMapping.Attributes) { switch (group.Difference) { case DifferenceType.Added: ITypeReference type = group.Representative.Attributes.First().Type; string attribName = type.FullName(); if (s_IgnorableAttributes.Contains(attribName)) break; differences.AddIncompatibleDifference(this, "Attribute '{0}' exists in the contract but not the implementation.", attribName, target.FullName()); added = true; break; case DifferenceType.Changed: //TODO: Add some more logic to check the two lists of attributes which have the same type. break; case DifferenceType.Removed: // Removing attributes is OK break; } } return added; }