/// <summary>
/// Check arguments of custom attribute.
/// </summary>
/// <param name="attributeArgs">The list of custom attribute arguments (types).</param>
private void CheckCustomAttributes(IEnumerable <CustomAttributeArgument> attributeArgs)
{
IMetadataScope forwardedFrom;
foreach (CustomAttributeArgument customAttributeArgument in attributeArgs)
{
TypeDefinition typeDefinition = customAttributeArgument.Value is TypeReference
? (customAttributeArgument.Value as TypeReference).Resolve(out forwardedFrom)
: customAttributeArgument.Type.Resolve(out forwardedFrom);
_sharedData.RemoveFromCandidates(forwardedFrom);
if (typeDefinition != null && !_sharedData.IsUsedTypeExists(typeDefinition.AssemblyQualifiedName()))
{
_sharedData.RemoveFromCandidates(typeDefinition.Scope);
if (!_sharedData.HasCandidateReferences)
{
return;
}
_sharedData.AddToUsedTypes(typeDefinition.AssemblyQualifiedName());
_interfaceCheckHelper.Check(typeDefinition, _sharedData);
}
}
}
/// <summary>
/// Performs class hierarchy checking.
/// </summary>
/// <param name="type">Specified type for checking.</param>
/// <param name="sharedData">Used types and assemblies candidates.</param>
public void Check(TypeDefinition type, CheckerSharedData sharedData)
{
try
{
if (type == null)
{
return;
}
var baseType = type.BaseType;
if (baseType == null || sharedData.UsedTypes.Contains(baseType.AssemblyQualifiedName()))
{
sharedData.AddToUsedTypes(type.AssemblyQualifiedName());
return;
}
IMetadataScope forwardedFrom;
var baseTypeDef = baseType.Resolve(out forwardedFrom);
sharedData.RemoveFromCandidates(forwardedFrom);
if (baseTypeDef != null)
{
sharedData.RemoveFromCandidates(baseTypeDef.Scope);
}
Check(baseTypeDef, sharedData);
sharedData.AddToUsedTypes(type.AssemblyQualifiedName());
}
catch (Exception ex)
{
throw Error.CheckType(type.AssemblyQualifiedName(),
string.Format(Resources.CleanExecutor_CheckTypeHierarchyException, type.AssemblyQualifiedName()), ex);
}
}
/// <summary>
/// Performs checking of type's interfaces.
/// </summary>
/// <param name="type">Specified type for checking.</param>
/// <param name="sharedData">Used types and assemblies candidates.</param>
public void Check(TypeDefinition type, CheckerSharedData sharedData)
{
try
{
IMetadataScope forwardedFrom;
foreach (TypeReference interfaceRef in type.GetInterfaces())
{
var interfaceDef = interfaceRef.Resolve(out forwardedFrom);
sharedData.RemoveFromCandidates(forwardedFrom);
if (interfaceDef != null)
{
if (interfaceDef.IsImport)
{
_importedCheckHelper.Check(interfaceDef, sharedData);
}
else
{
sharedData.RemoveFromCandidates(interfaceDef.Scope);
}
sharedData.AddToUsedTypes(interfaceDef.AssemblyQualifiedName());
}
if (!sharedData.HasCandidateReferences)
{
return;
}
}
}
catch (Exception ex)
{
throw Error.CheckType(type.AssemblyQualifiedName(),
string.Format(Resources.CleanExecutor_CheckTypeInterfacesException, type.AssemblyQualifiedName()), ex);
}
}
private void ResolveTypeReference(TypeReference paramTypeRef, CheckerSharedData sharedData)
{
var typeRef = GetNativeTypeOfTypeReference(paramTypeRef);
if (typeRef == null || typeRef.IsGenericParameter)
{
return;
}
IMetadataScope forwardedFrom;
var typeDef = typeRef.Resolve(out forwardedFrom);
sharedData.RemoveFromCandidates(forwardedFrom);
if (typeDef != null && !sharedData.IsUsedTypeExists(typeDef.AssemblyQualifiedName()))
{
sharedData.RemoveFromCandidates(typeDef.Scope);
_classCheckHeper.Check(typeDef, sharedData);
_interfaceCheckHelper.Check(typeDef, sharedData);
}
else if (typeDef == null)
{
sharedData.AddToUsedTypes(typeRef.AssemblyQualifiedName());
sharedData.RemoveFromCandidates(typeRef.Scope);
}
// check generic parameters of the type.
if (typeRef is GenericInstanceType && ((GenericInstanceType)typeRef).HasGenericArguments)
{
var genericType = ((GenericInstanceType)typeRef);
foreach (var genericArg in genericType.GenericArguments)
{
ResolveTypeReference(genericArg, sharedData);
}
}
}
