private IEnumerable <Relation> UsagesForConreteType( TypeDefinition type, Func <TypeReference, bool> typeFilter, Func <MethodDefinition, bool> methodFilter) { //resolve type to get interfaces, methods and code //var typeDef = type.SmartResolve(); Func <TypeReference, bool> compilerGenerated = x => x.FullName.StartsWith("<>") || (x.SmartResolve()?.HasCustomAttribute <CompilerGeneratedAttribute>() ?? false); var baseClass = type.BaseType != null ? Relation.InheritedFrom(type, type.BaseType).AsEnumerableWithOneItem() : Enumerable.Empty <Relation>(); var nested = type.NestedTypes.Select(x => Relation.ContainsNested(type, x)); var interfaceImpls = InterfaceMap.GetValue(type, Enumerable.Empty <TypeDefinition>()).Select(x => Relation.ImplementedBy(type, x)).ToList(); var interfaces = type.Interfaces.Select(x => Relation.Implements(type, x)).ToList(); var methodsToInspect = type.Methods.Where(x => x.HasBody && methodFilter(x)).ToList(); var usageAsMethodParameter = from m in methodsToInspect from p in m.Parameters select Relation.AsMethodParameter(type, m, p.ParameterType); var usageAsReturnType = from m in methodsToInspect select Relation.AsMethodReturnType(type, m, m.ReturnType); var usageInCode = from m in methodsToInspect from i in m.Body.Instructions where i.Operand != null let u = GetUsagesInConreteInstruction(m, i) where u != null select u; var allUsages = baseClass .Concat(nested) //.Concat(generics) .Concat(interfaces) .Concat(interfaceImpls) .Concat(usageAsMethodParameter) .Concat(usageAsReturnType) .Concat(usageInCode) .Where(x => typeFilter(x.Target)); //.Where(x => !x.Target.IsPrimitive & !x.Target.Namespace.StartsWith("System")) //.Where(x => !compilerGenerated(x.Target)); //var generics = type.GetGenericArguments().Select(x => UsageInfo.AsGenericParameter(typeDef, x)).ToList(); return(allUsages); }