public static bool HasKnownAttribute(this CustomAttributeHandleCollection customAttributes, MetadataReader metadata, KnownAttribute type)
{
foreach (var handle in customAttributes)
{
var customAttribute = metadata.GetCustomAttribute(handle);
if (customAttribute.IsKnownAttribute(metadata, type))
{
return(true);
}
}
return(false);
}
internal static bool IsKnownAttribute(this SRM.CustomAttribute attr, MetadataReader metadata, KnownAttribute attrType)
{
return(attr.GetAttributeType(metadata).IsKnownType(metadata, attrType));
}
internal static bool IsKnownType(this EntityHandle handle, MetadataReader reader, KnownAttribute knownType)
{
return(GetFullTypeName(handle, reader) == knownType.GetTypeName());
}
/// <summary>
/// If any of the attributes are known types.
/// </summary>
/// <param name="attributes">The attribute to check.</param>
/// <param name="type">The known type to check.</param>
/// <returns>If any of the attributes are of the known type.</returns>
public static bool HasKnownAttribute(this IEnumerable <AttributeWrapper> attributes, KnownAttribute type)
{
if (attributes == null)
{
throw new ArgumentNullException(nameof(attributes));
}
foreach (var customAttribute in attributes)
{
if (customAttribute.KnownAttributeType == type)
{
return(true);
}
}
return(false);
}
/// <summary>
/// If there is a attribute wrapper matching the known attribute get that wrapper.
/// </summary>
/// <param name="attributes">The collection of attributes to check.</param>
/// <param name="type">The type of attribute we want to find.</param>
/// <param name="wrapper">Output value of the attribute if found.</param>
/// <returns>If the attribute was found or not.</returns>
public static bool TryGetKnownAttribute(this IEnumerable <AttributeWrapper> attributes, KnownAttribute type, out AttributeWrapper wrapper)
{
if (attributes == null)
{
throw new ArgumentNullException(nameof(attributes));
}
foreach (var customAttribute in attributes)
{
if (customAttribute.KnownAttributeType == type)
{
wrapper = customAttribute;
return(true);
}
}
wrapper = default !;
/// <summary>
/// Gets whether the parameter has an attribute of the specified attribute type (or derived attribute types).
/// </summary>
/// <param name="parameter">The parameter on which the attributes are declared.</param>
/// <param name="attributeType">The attribute type to look for.</param>
public static bool HasAttribute(this IParameter parameter, KnownAttribute attrType)
{
return(GetAttribute(parameter, attrType) != null);
}
/// <summary>
/// Gets the attribute of the specified attribute type (or derived attribute types).
/// </summary>
/// <param name="parameter">The parameter on which the attributes are declared.</param>
/// <param name="attributeType">The attribute type to look for.</param>
/// <returns>
/// Returns the attribute that was found; or <c>null</c> if none was found.
/// </returns>
public static IAttribute GetAttribute(this IParameter parameter, KnownAttribute attributeType)
{
return(parameter.GetAttributes().FirstOrDefault(a => a.AttributeType.IsKnownType(attributeType)));
}
/// <summary>
/// Gets whether the entity has an attribute of the specified attribute type (or derived attribute types).
/// </summary>
/// <param name="entity">The entity on which the attributes are declared.</param>
/// <param name="attributeType">The attribute type to look for.</param>
/// <param name="inherit">
/// Specifies whether attributes inherited from base classes and base members
/// (if the given <paramref name="entity"/> in an <c>override</c>)
/// should be returned.
/// </param>
public static bool HasAttribute(this IEntity entity, KnownAttribute attrType, bool inherit = false)
{
return(GetAttribute(entity, attrType, inherit) != null);
}
/// <summary>
/// Gets the attribute of the specified attribute type (or derived attribute types).
/// </summary>
/// <param name="entity">The entity on which the attributes are declared.</param>
/// <param name="attributeType">The attribute type to look for.</param>
/// <param name="inherit">
/// Specifies whether attributes inherited from base classes and base members
/// (if the given <paramref name="entity"/> in an <c>override</c>)
/// should be returned.
/// </param>
/// <returns>
/// Returns the attribute that was found; or <c>null</c> if none was found.
/// If inherit is true, an from the entity itself will be returned if possible;
/// and the base entity will only be searched if none exists.
/// </returns>
public static IAttribute GetAttribute(this IEntity entity, KnownAttribute attributeType, bool inherit = false)
{
return(GetAttributes(entity, inherit).FirstOrDefault(a => a.AttributeType.IsKnownType(attributeType)));
}
/// <summary>
/// Gets whether the type is the specified known type.
/// For generic known types, this returns true any parameterization of the type (and also for the definition itself).
/// </summary>
internal static bool IsKnownType(this IType type, KnownAttribute knownType)
{
var def = type.GetDefinition();
return(def != null && def.FullTypeName.IsKnownType(knownType));
}
internal static bool IsKnownType(this TopLevelTypeName typeName, KnownAttribute knownType)
{
return(typeName == knownType.GetTypeName());
}
/// <summary>
/// Construct a builtin attribute.
/// </summary>
public void Add(KnownAttribute type, ImmutableArray <CustomAttributeTypedArgument <IType> > fixedArguments)
{
Add(new DefaultAttribute(module.GetAttributeType(type), fixedArguments,
ImmutableArray.Create <CustomAttributeNamedArgument <IType> >()));
}
/// <summary>
/// Construct a builtin attribute with a single positional argument of known type.
/// </summary>
public void Add(KnownAttribute type, TopLevelTypeName argType, object argValue)
{
Add(type, ImmutableArray.Create(new CustomAttributeTypedArgument <IType>(module.Compilation.FindType(argType), argValue)));
}
/// <summary>
/// Add a builtin attribute without any arguments.
/// </summary>
public void Add(KnownAttribute type)
{
// use the assemblies' cache for simple attributes
Add(module.MakeAttribute(type));
}
public AttributeBuilder(MetadataModule module, KnownAttribute attributeType)
: this(module, module.GetAttributeType(attributeType))
{
}
IEnumerable <IEnumerable <ISymbol> > HandleBuiltinAttribute(KnownAttribute attribute, AnalyzerScope scope)
{
IEnumerable <ISymbol> ScanTypes(DecompilerTypeSystem ts)
{
return(ts.MainModule.TypeDefinitions
.Where(t => t.HasAttribute(attribute)));
}
IEnumerable <ISymbol> ScanMethods(DecompilerTypeSystem ts)
{
return(ts.MainModule.TypeDefinitions
.SelectMany(t => t.Members.OfType <IMethod>())
.Where(m => m.HasAttribute(attribute))
.Select(m => m.AccessorOwner ?? m));
}
IEnumerable <ISymbol> ScanFields(DecompilerTypeSystem ts)
{
return(ts.MainModule.TypeDefinitions
.SelectMany(t => t.Fields)
.Where(f => f.HasAttribute(attribute)));
}
IEnumerable <ISymbol> ScanProperties(DecompilerTypeSystem ts)
{
return(ts.MainModule.TypeDefinitions
.SelectMany(t => t.Properties)
.Where(p => p.HasAttribute(attribute)));
}
IEnumerable <ISymbol> ScanParameters(DecompilerTypeSystem ts)
{
return(ts.MainModule.TypeDefinitions
.SelectMany(t => t.Members.OfType <IMethod>())
.Where(m => m.Parameters.Any(p => p.HasAttribute(attribute)))
.Select(m => m.AccessorOwner ?? m));
}
foreach (Decompiler.Metadata.PEFile module in scope.GetAllModules())
{
var ts = new DecompilerTypeSystem(module, module.GetAssemblyResolver());
switch (attribute)
{
case KnownAttribute.Serializable:
case KnownAttribute.ComImport:
case KnownAttribute.StructLayout:
yield return(ScanTypes(ts));
break;
case KnownAttribute.DllImport:
case KnownAttribute.PreserveSig:
case KnownAttribute.MethodImpl:
yield return(ScanMethods(ts));
break;
case KnownAttribute.FieldOffset:
case KnownAttribute.NonSerialized:
yield return(ScanFields(ts));
break;
case KnownAttribute.MarshalAs:
yield return(ScanFields(ts));
yield return(ScanParameters(ts));
goto case KnownAttribute.Out;
case KnownAttribute.Optional:
case KnownAttribute.In:
case KnownAttribute.Out:
yield return(ScanParameters(ts));
break;
case KnownAttribute.IndexerName:
yield return(ScanProperties(ts));
break;
}
}
}
