public RawDependency([NotNull] RawUsingItem usingItem, [NotNull] RawUsedItem usedItem,
DotNetUsage usage, [CanBeNull] SequencePoint sequencePoint, AbstractDotNetAssemblyDependencyReader readerForUsedItem)
{
if (usingItem == null)
{
throw new ArgumentNullException(nameof(usingItem));
}
if (usedItem == null)
{
throw new ArgumentNullException(nameof(usedItem));
}
UsingItem = usingItem;
UsedItem = usedItem;
Usage = usage;
_readerForUsedItem = readerForUsedItem;
_sequencePoint = sequencePoint;
}
/// <summary>
/// Create a single dependency to the calledType or (if passed) calledType+method.
/// Create additional dependencies for each generic parameter type of calledType.
/// </summary>
private IEnumerable <RawDependency> CreateTypeAndMethodDependencies([NotNull] RawUsingItem usingItem,
[NotNull] ItemType usedItemType, [CanBeNull, ItemNotNull] string[] usedMarkers, [NotNull] TypeReference usedType,
DotNetUsage usage, [CanBeNull] SequencePoint sequencePoint, [NotNull] string memberName, WorkingGraph readingGraph)
{
if (usedType is TypeSpecification)
{
// E.g. the reference type System.int&, which is used for out parameters.
// or an arraytype?!?
usedType = ((TypeSpecification)usedType).ElementType;
}
if (!(usedType is GenericInstanceType) && !(usedType is GenericParameter))
{
// Here, we do not look at generic type parameters; we would have to
// untangle the usage of an actual (non-type-parameter) type's member
// to get a useful Dependency for the user.
// Generic parameters and their constraints are handled above.
RawUsedItem usedItem = CreateUsedItem(usedItemType, usedType, memberName, usedMarkers, readingGraph);
yield return(new RawDependency(usingItem, usedItem, usage, sequencePoint,
_readingContext.ReaderGang.OfType <AbstractDotNetAssemblyDependencyReader>().FirstOrDefault(r => r.AssemblyName == usedItem.AssemblyName)));
}
var genericInstanceType = usedType as GenericInstanceType;
if (genericInstanceType != null)
{
foreach (TypeReference genericArgument in genericInstanceType.GenericArguments)
{
foreach (var dependency in CreateTypeAndMethodDependencies(usingItem, DOTNETTYPE,
GetMemberMarkers(Resolve(genericArgument), _typeDefinitionMarkers), genericArgument,
usage: DotNetUsage._usesasgenericargument, sequencePoint: sequencePoint, memberName: genericArgument.Name,
readingGraph: readingGraph))
{
yield return(dependency);
}
}
}
}
private IEnumerable <RawDependency> CreateTypeAndMethodDependencies(RawUsingItem usingItem,
TypeReference usedType, DotNetUsage dotNetUsage, WorkingGraph readingGraph)
{
return(CreateTypeAndMethodDependencies(usingItem,
DOTNETTYPE, GetMemberMarkers(Resolve(usedType), _typeDefinitionMarkers), usedType,
usage: dotNetUsage, sequencePoint: null, memberName: "", readingGraph: readingGraph));
}
