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