/// <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);
}
}
/// <summary>
/// Performs imported types checking.
/// </summary>
/// <param name="type">Specified type for checking.</param>
/// <param name="checkerData">Used types and assemblies candidates.</param>
public void Check(TypeDefinition type, CheckerSharedData checkerData)
{
foreach (ProjectReference projectReference in checkerData.CandidateReferences)
{
AssemblyDefinition assemblyDefinition = null;
if (!_assemblyDefinitions.TryGetValue(projectReference, out assemblyDefinition))
{
assemblyDefinition = ReadAssembly(projectReference.Location, Path.GetDirectoryName(projectReference.Location));
if (assemblyDefinition != null)
{
_assemblyDefinitions.Add(projectReference, assemblyDefinition);
}
}
if (assemblyDefinition != null)
{
var hasType = assemblyDefinition.Modules
.SelectMany(m => m.Types)
.Count(t => t.FullName.Equals(type.FullName, StringComparison.OrdinalIgnoreCase)) > 0;
if (hasType)
{
checkerData.RemoveFromCandidates(projectReference);
break;
}
}
}
}
/// <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 property's parameters.
/// </summary>
/// <param name="memberRef">The specified property.</param>
/// <param name="sharedData">Used types and assemblies candidates.</param>
internal void CheckPropertyParameters(PropertyReference propertyRef, CheckerSharedData sharedData)
{
ResolveTypeReference(propertyRef.PropertyType, sharedData);
foreach (var paramDef in propertyRef.Parameters)
{
ResolveTypeReference(paramDef.ParameterType, sharedData);
}
}
/// <summary>
/// Performs checking method's parameters.
/// </summary>
/// <param name="memberRef">The specified method.</param>
/// <param name="sharedData">Used types and assemblies candidates.</param>
internal void CheckMethodParameters(MethodReference methodRef, CheckerSharedData sharedData)
{
ResolveTypeReference(methodRef.ReturnType, sharedData);
if (methodRef.HasParameters)
{
foreach (var paramDef in methodRef.Parameters)
{
ResolveTypeReference(paramDef.ParameterType, sharedData);
}
}
}
/// <summary>
/// Check not-overloaded member reference.
/// </summary>
/// <param name="memberRef">The member reference.</param>
/// <param name="sharedData">Used types and assemblies candidates.</param>
private void CheckMemberReference(MemberReference memberRef, CheckerSharedData sharedData)
{
try
{
_helper.Check(memberRef, sharedData);
}
catch (Exception ex)
{
throw Error.CheckType(memberRef.DeclaringType.AssemblyQualifiedName(),
string.Format(Resources.MemberReferencesCheckHelper_CheckMemberReferenceException,
memberRef.FullName, memberRef.Module.AssemblyQualifiedName()), ex);
}
}
/// <summary>
/// Performs checking of member reference types.
/// </summary>
/// <param name="memberRef">The specified member reference.</param>
/// <param name="sharedData">Used types and assemblies candidates.</param>
public void Check(MemberReference memberRef, CheckerSharedData sharedData)
{
if (memberRef is MethodReference)
{
CheckMethodParameters(memberRef as MethodReference, sharedData);
}
else if (memberRef is PropertyReference)
{
CheckPropertyParameters(memberRef as PropertyReference, sharedData);
}
else if (memberRef is FieldReference)
{
CheckFieldType(memberRef as FieldReference, sharedData);
}
else if (memberRef is EventReference)
{
CheckEventType(memberRef as EventReference, sharedData);
}
}
/// <summary>
/// Performs checking of referenced members of the specified type.
/// </summary>
/// <param name="type">The specified type.</param>
/// <param name="sharedData">Used types and assemblies candidates.</param>
/// <param name="evaluator">The project evaluator.</param>
public void Check(TypeReference typeRef, CheckerSharedData sharedData, IProjectEvaluator evaluator)
{
try
{
foreach (MemberReference memberRef in GetMemberReferences(typeRef, evaluator))
{
EvaluateMemberReference(memberRef, sharedData);
if (!sharedData.HasCandidateReferences)
{
return;
}
}
}
catch (Exception ex)
{
throw Error.CheckType(typeRef.AssemblyQualifiedName(),
string.Format(Resources.MemberReferencesCheckHelper_CheckTypeException, typeRef.AssemblyQualifiedName()), ex);
}
}
/// <summary>
/// Check overloaded methods.
/// </summary>
/// <param name="methods">The overloaded methods.</param>
/// <param name="sharedData">Used types and assemblies candidates.</param>
private void CheckOverloadedMethods(IEnumerable <MethodDefinition> methods, CheckerSharedData sharedData)
{
try
{
foreach (var method in methods)
{
_helper.CheckMethodParameters(method, sharedData);
}
}
catch (Exception ex)
{
var method = methods.First();
string methodName = string.Format("{0}.{1}", method.DeclaringType.FullName, method.Name);
int parametersAmount = method.Parameters.Count;
throw Error.CheckType(method.DeclaringType.AssemblyQualifiedName(),
string.Format(Resources.MemberReferencesCheckHelper_CheckOverloadedMethodsException,
methodName, parametersAmount, method.Module.AssemblyQualifiedName()), ex);
}
}
/// <summary>
/// Analyse members reference (is it method? it it overloaded? etc).
/// </summary>
/// <param name="memberRef">The analysed member reference.</param>
/// <param name="sharedData">Used types and assemblies candidates.</param>
private void EvaluateMemberReference(MemberReference memberRef, CheckerSharedData sharedData)
{
if (!(memberRef is MethodReference) ||
(!(memberRef as MethodReference).HasParameters))
{
CheckMemberReference(memberRef, sharedData);
return;
}
var methodRef = memberRef as MethodReference;
IEnumerable <MethodDefinition> methods = GetOverloadedMethods(memberRef.DeclaringType, methodRef.Name, methodRef.Parameters.Count);
if (methods.Count() > 1)
{
CheckOverloadedMethods(methods, sharedData);
}
else
{
CheckMemberReference(memberRef, sharedData);
}
}
/// <summary>
/// Performs type's attributes checking.
/// </summary>
/// <param name="type">The specified type.</param>
/// <param name="sharedData">Used types and assemblies candidates.</param>
public void Check(TypeDefinition type, CheckerSharedData sharedData)
{
try
{
_sharedData = sharedData;
foreach (var checkAction in _checkActionList)
{
checkAction(type);
if (!_sharedData.HasCandidateReferences)
{
return;
}
}
}
catch (Exception ex)
{
throw Error.CheckType(type.AssemblyQualifiedName(),
string.Format(Resources.CleanExecutor_CheckTypeAttributesException, 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);
}
}
}
/// <summary>
/// Performs checking field's type.
/// </summary>
/// <param name="memberRef">The specified field.</param>
/// <param name="sharedData">Used types and assemblies candidates.</param>
internal void CheckFieldType(FieldReference fieldRef, CheckerSharedData sharedData)
{
ResolveTypeReference(fieldRef.FieldType, sharedData);
}
/// <summary>
/// Performs checking event's type.
/// </summary>
/// <param name="memberRef">The specified event.</param>
/// <param name="sharedData">Used types and assemblies candidates.</param>
internal void CheckEventType(EventReference eventRef, CheckerSharedData sharedData)
{
ResolveTypeReference(eventRef.EventType, sharedData);
}
