/// <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); }