/// <summary>
/// Asserts the attribute.
/// </summary>
/// <param name="field">The field.</param>
/// <returns></returns>
public static T AssertAttribute <T>(ICustomAttributeProvider attributeProvider)
where T : Attribute
{
Assert.AreEqual <int>(1, attributeProvider.GetCustomAttributes(typeof(T), true).Length,
"Attribute {0} not found in {1}", typeof(T).Name, attributeProvider.ToString());
return(attributeProvider.GetCustomAttributes(typeof(T), true).GetValue(0) as T);
}
private static string TryGetName(ICustomAttributeProvider from)
{
Type t = from as Type;
if (t != null)
{
return(t.FullName);
}
else
{
MemberInfo m = from as MemberInfo;
if (m != null)
{
return(m.ReflectedType.FullName + "." + m.Name);
}
else
{
Assembly ass = from as Assembly;
if (ass != null)
{
return(ass.FullName);
}
else
{
return(from.ToString());
}
}
}
}
public static string ToShortNameString(this ICustomAttributeProvider cat)
{
var atrDisp = ReflexionUtils.GetAtribute <DisplayAttribute>(cat);
if (atrDisp != null)
{
return(atrDisp.GetShortName());
}
if (cat is PropertyInfo)
{
return((cat as PropertyInfo).Name);
}
if (cat is MemberInfo)
{
return((cat as MemberInfo).Name);
}
if (cat is FieldInfo)
{
return((cat as FieldInfo).Name);
}
if (cat is Type)
{
return((cat as Type).Name);
}
return(cat.ToString());
}
bool AnalyzeCustomAttributes(ICustomAttributeProvider ca)
{
if (!ca.HasCustomAttributes)
{
return(false);
}
bool ret = false;
foreach (var i in ca.CustomAttributes)
{
foreach (var arg in i.ConstructorArguments)
{
AnalyzeCustomAttributeArgs(arg);
}
int idx = 0;
foreach (var arg in i.Fields)
{
FieldDefinition field;
if (i.AttributeType is TypeDefinition &&
(field = (i.AttributeType as TypeDefinition).Fields.SingleOrDefault(_ => _.Name == arg.Name)) != null)
{
((field as IAnnotationProvider).Annotations[RenRef] as List <IReference>).Add(
new CustomAttributeMemberReference(i, idx, true));
}
AnalyzeCustomAttributeArgs(arg.Argument);
idx++;
}
idx = 0;
foreach (var arg in i.Properties)
{
PropertyDefinition prop;
if (i.AttributeType is TypeDefinition &&
(prop = (i.AttributeType as TypeDefinition).Properties.SingleOrDefault(_ => _.Name == arg.Name)) != null)
{
((prop as IAnnotationProvider).Annotations[RenRef] as List <IReference>).Add(
new CustomAttributeMemberReference(i, idx, false));
}
AnalyzeCustomAttributeArgs(arg.Argument);
idx++;
}
if (Database.ExcludeAttributes.Contains(i.AttributeType.FullName) && ca is IAnnotationProvider)
{
(ca as IAnnotationProvider).Annotations[RenOk] = false;
Confuser.Database.AddEntry(DB_SRC, ca.ToString(), i.AttributeType.FullName + " => Not renamed");
ret = true;
}
}
return(ret);
}
static string ProviderToString(ICustomAttributeProvider provider)
{
if (provider is MemberReference member)
{
return(member.DeclaringType.FullName + "." + member.Name);
}
if (provider is MethodReturnType returnType)
{
return(ProviderToString((ICustomAttributeProvider)returnType.Method));
}
return(provider.ToString());
}
string ToString(ICustomAttributeProvider cap)
{
var s = cap.ToString();
if (cap is MemberInfo mi)
{
var i = s.IndexOf(' ');
if (i != -1)
{
// a method/property without the declaring type is hard to track down
s = s.Insert(i + 1, mi.DeclaringType + "::");
}
}
return(s);
}
public T GetCustomAttribute <T> (ICustomAttributeProvider provider) where T : System.Attribute
{
if (provider is null)
{
return(null);
}
var rv = GetCustomAttributes <T> (provider);
if (rv == null || rv.Length == 0)
{
return(null);
}
if (rv.Length == 1)
{
return(rv [0]);
}
string name = (provider as MemberInfo)?.Name;
if (provider is ParameterInfo)
{
var pi = (ParameterInfo)provider;
name = $"the method {pi.Member.DeclaringType.FullName}.{pi.Member.Name}'s parameter #{pi.Position} ({pi.Name})";
}
else if (provider is Type type)
{
name = $"the type {type.FullName}";
}
else if (provider is MemberInfo)
{
var mi = (MemberInfo)provider;
name = $"the member {mi.DeclaringType.FullName}.{mi.Name}";
}
else if (provider is Assembly)
{
name = $"the assembly {((Assembly) provider).FullName}";
}
else if (provider is Module)
{
name = $"the module {((Module) provider).FullyQualifiedName}";
}
else
{
name = $"the member {provider.ToString ()}";
}
throw ErrorHelper.CreateError(1059, rv.Length, typeof(T).FullName, name);
}
private static string FormatName(ICustomAttributeProvider attributeProvider)
{
var t = (Type)attributeProvider;
if (t != null)
{
return(t.FormatName());
}
var m = (MemberInfo)attributeProvider;
if (m != null)
{
return(m.DeclaringType.FormatName() + "." + m.Name);
}
return(attributeProvider.ToString());
}
public static string GetDescription(this ICustomAttributeProvider type)
{
DescriptionAttribute attr = type.GetCustomAttributes(typeof(DescriptionAttribute), false).FirstOrDefault() as DescriptionAttribute;
if (attr != null)
{
return(attr.Description);
}
else
{
if (type is FieldInfo)
{
return(((FieldInfo)type).Name.Replace(Consts.spaceSymbolPlaceholder, ' '));
}
return(type.ToString().Replace(Consts.spaceSymbolPlaceholder, ' '));
}
}
public static IEnumerable <Attribute> GetCustomAttributes(this ICustomAttributeProvider provider, Type cType)
{
var key = provider.ToString();
var paramDef = provider as ParameterDefinition;
var param = provider as ParameterReference;
if (paramDef != null)
{
key = string.Concat(paramDef.Method.ToString(), paramDef.Name, paramDef.Index.ToString());
}
else if (param != null)
{
key = string.Concat(param.Resolve().Method.ToString(), param.Name, param.Index.ToString());
}
return(customAttributes.GetOrAdd(key, _ =>
{
return GetCustomAttributesFor(provider, cType);
}));
}
public static string GetDisplayName(this ICustomAttributeProvider provider)
{
if (provider.HasAttribute <DisplayNameAttribute>())
{
return(provider.GetAttribute <DisplayNameAttribute>().DisplayName);
}
else
{
string name = provider.ToString().Prettify();
MemberInfo mi = provider as MemberInfo;
if (mi != null)
{
name = mi.Name.Prettify();
}
string[] arr = name.Split(' ');
if ((arr.Length > 1) && (arr[arr.Length - 1].ToLower() == "id"))
{
arr[arr.Length - 1] = "";
}
return(arr.Delimit(" ", "").TrimEnd());
}
}
public string Create(Type attrType, ICustomAttributeProvider provider)
{
if (attrType == null) throw new ArgumentNullException(nameof(attrType));
if (provider == null) throw new ArgumentNullException(nameof(provider));
string name;
var mi = provider as MemberInfo;
var t = mi as Type;
var p = provider as ParameterInfo;
var a = provider as Assembly;
var m = provider as System.Reflection.Module;
if (t != null)
{
name = t.FullName;
}
else if (p != null)
{
name = $"{(p.Member.DeclaringType ?? p.Member.ReflectedType)?.FullName}|{p.Member.Name}|{p.Name}";
}
else if (mi != null)
{
var decType = mi.DeclaringType ?? mi.ReflectedType;
name = $"{decType?.FullName}|{mi}";
}
else if (a != null)
{
name = a.FullName;
}
else if (m != null)
{
name = m.FullyQualifiedName;
}
else
{
name = provider.ToString();
}
return $"{attrType.FullName}|{name}";
}
static internal T GetRequiredSingleAttribute <T>(ICustomAttributeProvider attrProvider, Type[] attrTypeGroup)
where T : class
{
T result = GetSingleAttribute <T>(attrProvider, attrTypeGroup);
if (result == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.couldnTFindRequiredAttributeOfTypeOn2, typeof(T), attrProvider.ToString())));
}
return(result);
}
static internal T GetSingleAttribute <T>(ICustomAttributeProvider attrProvider)
where T : class
{
Type attrType = typeof(T);
object[] attrs = GetCustomAttributes(attrProvider, attrType);
if (attrs == null || attrs.Length == 0)
{
return(null);
}
else if (attrs.Length > 1)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.tooManyAttributesOfTypeOn2, attrType, attrProvider.ToString())));
}
else
{
return(attrs[0] as T);
}
}
internal static T GetRequiredSingleAttribute <T>(ICustomAttributeProvider attrProvider, Type[] attrTypeGroup) where T : class
{
T singleAttribute = GetSingleAttribute <T>(attrProvider, attrTypeGroup);
if (singleAttribute == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("couldnTFindRequiredAttributeOfTypeOn2", new object[] { typeof(T), attrProvider.ToString() })));
}
return(singleAttribute);
}
private bool ProcessAttribute(ICustomAttributeProvider provider, Marking setting)
{
CustomAttribute att = GetAttribute(provider.CustomAttributes, "ConfusingAttribute");
if (att == null)
{
setting.StartLevel();
return(false);
}
CustomAttributeNamedArgument stripArg = att.Properties.FirstOrDefault(arg => arg.Name == "StripAfterObfuscation");
bool strip = true;
if (!stripArg.Equals(default(CustomAttributeNamedArgument)))
{
strip = (bool)stripArg.Argument.Value;
}
if (strip)
{
provider.CustomAttributes.Remove(att);
}
CustomAttributeNamedArgument excludeArg = att.Properties.FirstOrDefault(arg => arg.Name == "Exclude");
bool exclude = false;
if (!excludeArg.Equals(default(CustomAttributeNamedArgument)))
{
exclude = (bool)excludeArg.Argument.Value;
}
if (exclude)
{
setting.CurrentConfusions.Clear();
}
CustomAttributeNamedArgument applyToMembersArg = att.Properties.FirstOrDefault(arg => arg.Name == "ApplyToMembers");
bool applyToMembers = true;
if (!applyToMembersArg.Equals(default(CustomAttributeNamedArgument)))
{
applyToMembers = (bool)applyToMembersArg.Argument.Value;
}
if (applyToMembers)
{
setting.StartLevel();
}
else
{
setting.SkipLevel();
}
try
{
if (!exclude)
{
CustomAttributeNamedArgument featureArg = att.Properties.FirstOrDefault(arg => arg.Name == "Config");
string feature = "all";
if (!featureArg.Equals(default(CustomAttributeNamedArgument)))
{
feature = (string)featureArg.Argument.Value;
}
if (string.Equals(feature, "all", StringComparison.OrdinalIgnoreCase))
{
FillPreset(Preset.Maximum, setting.CurrentConfusions);
}
else if (string.Equals(feature, "default", StringComparison.OrdinalIgnoreCase))
{
FillPreset(Preset.Normal, setting.CurrentConfusions);
}
else
{
ProcessConfig(feature, setting.CurrentConfusions);
}
}
return(exclude && applyToMembers);
}
catch
{
cr.Log("Warning: Cannot process ConfusingAttribute at '" + provider.ToString() + "'. ConfusingAttribute ignored.");
return(false);
}
}
void AddSuppression(SuppressMessageInfo info, ICustomAttributeProvider provider)
{
if (!_suppressions.TryGetValue(provider, out var suppressions))
{
suppressions = new Dictionary <int, SuppressMessageInfo> ();
_suppressions.Add(provider, suppressions);
}
else if (suppressions.ContainsKey(info.Id))
{
string?elementName = provider is MemberReference memberRef?memberRef.GetDisplayName() : provider.ToString();
_context.LogMessage($"Element '{elementName}' has more than one unconditional suppression. Note that only the last one is used.");
}
suppressions[info.Id] = info;
}
bool AnalyzeCustomAttributes(ICustomAttributeProvider ca)
{
if (!ca.HasCustomAttributes) return false;
bool ret = false;
foreach (var i in ca.CustomAttributes)
{
foreach (var arg in i.ConstructorArguments)
AnalyzeCustomAttributeArgs(arg);
int idx = 0;
foreach (var arg in i.Fields)
{
FieldDefinition field;
if (i.AttributeType is TypeDefinition &&
(field = (i.AttributeType as TypeDefinition).Fields.SingleOrDefault(_ => _.Name == arg.Name)) != null)
((field as IAnnotationProvider).Annotations[RenRef] as List<IReference>).Add(
new CustomAttributeMemberReference(i, idx, true));
AnalyzeCustomAttributeArgs(arg.Argument);
idx++;
}
idx = 0;
foreach (var arg in i.Properties)
{
PropertyDefinition prop;
if (i.AttributeType is TypeDefinition &&
(prop = (i.AttributeType as TypeDefinition).Properties.SingleOrDefault(_ => _.Name == arg.Name)) != null)
((prop as IAnnotationProvider).Annotations[RenRef] as List<IReference>).Add(
new CustomAttributeMemberReference(i, idx, false));
AnalyzeCustomAttributeArgs(arg.Argument);
idx++;
}
if (Database.ExcludeAttributes.Contains(i.AttributeType.FullName) && ca is IAnnotationProvider)
{
(ca as IAnnotationProvider).Annotations[RenOk] = false;
Confuser.Database.AddEntry(DB_SRC, ca.ToString(), i.AttributeType.FullName + " => Not renamed");
ret = true;
}
}
return ret;
}
public DisplayInfoBase(object target, ICustomAttributeProvider mi)
{
_target = target;
_member = mi;
if (mi is MethodInfo)
{
_name = ((MethodInfo)mi).Name;
}
else if (mi is ParameterInfo)
{
_name = ((ParameterInfo)mi).Name;
}
else if (mi is PropertyInfo)
{
_name = ((PropertyInfo)mi).Name;
}
InterpreterException.Assert(_name != null, "Unknown type " + mi.ToString());
_reflectedType = target == null ? null : target is Type ? (Type)target : target.GetType();
_description = _member.ToString();
_category = _target.GetType().Name;
_visible = true;
foreach (DisplayNameAttribute a in _member.GetCustomAttributes(typeof(DisplayNameAttribute), true))
{
_name = a.DisplayName;
}
foreach (DescriptionAttribute a in _member.GetCustomAttributes(typeof(DescriptionAttribute), true))
{
_description = String.Format("{0}", a.Description);
}
foreach (CategoryAttribute a in _member.GetCustomAttributes(typeof(CategoryAttribute), true))
{
_category = String.Format("{0}", a.Category);
}
foreach (BrowsableAttribute a in _member.GetCustomAttributes(typeof(BrowsableAttribute), true))
{
_visible = a.Browsable;
}
List <string> names = new List <string>();
foreach (DisplayInfoAttribute a in mi.GetCustomAttributes(typeof(DisplayInfoAttribute), true))
{
if (!String.IsNullOrEmpty(a.DisplayName))
{
_name = a.DisplayName;
}
names.AddRange(a.AliasNames);
if (!String.IsNullOrEmpty(a.Description))
{
_description = a.Description;
}
if (!String.IsNullOrEmpty(a.Category))
{
_category = a.Category;
}
_visible &= a.Visible;
}
names.Insert(0, _name);
foreach (AliasNameAttribute a in _member.GetCustomAttributes(typeof(AliasNameAttribute), true))
{
names.Add(a.Name);
}
_allNames = names.ToArray();
try { _attributes = mi.GetCustomAttributes(true); }
catch { _attributes = new object[0]; }
}
internal static T GetSingleAttribute <T>(ICustomAttributeProvider attrProvider) where T : class
{
Type attrType = typeof(T);
object[] customAttributes = GetCustomAttributes(attrProvider, attrType);
if (customAttributes.Length == 0)
{
return(default(T));
}
if (customAttributes.Length > 1)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("tooManyAttributesOfTypeOn2", new object[] { attrType, attrProvider.ToString() })));
}
return(customAttributes[0] as T);
}
static internal object GetRequiredSingleAttribute(Type attrType, ICustomAttributeProvider attrProvider, Type[] attrTypeGroup)
{
object result = GetSingleAttribute(attrType, attrProvider, attrTypeGroup);
if (result == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.couldnTFindRequiredAttributeOfTypeOn2, attrType, attrProvider.ToString())));
}
return(result);
}
static internal object GetSingleAttribute(Type attrType, ICustomAttributeProvider attrProvider)
{
object[] attrs = GetCustomAttributes(attrProvider, attrType);
if (attrs.Length == 0)
{
return(null);
}
else if (attrs.Length > 1)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.tooManyAttributesOfTypeOn2, attrType, attrProvider.ToString())));
}
else
{
return(attrs[0]);
}
}
public static T GetCustomAttributeOfType <T>(this ICustomAttributeProvider attributesProvider, bool inherited = false) where T : Attribute
{
var attributes = attributesProvider.GetCustomAttributesOfType <T>(inherited);
if (attributes.Count() != 1)
{
throw new SoftwareException("{0} did not contain (or contained more than one) attribute {1}", attributesProvider.ToString(), typeof(T).Name);
}
return(attributes.Single());
}
