/// <summary>
/// </summary>
/// <param name="allTypes">
/// </param>
/// <param name="genericMethodSpecializations">
/// </param>
private static void DiscoverAllGenericMethodsOfInterfaces(
IEnumerable <IType> allTypes,
ReadingTypesContext readingTypesContext)
{
var genericMethodSpecializations = readingTypesContext.GenericMethodSpecializations;
var allSpecializedMethodsOfInterfaces = genericMethodSpecializations.Where(m => m.DeclaringType.IsInterface && m.IsGenericMethod).Distinct().ToList();
var allSpecializedMethodsOfInterfacesGroupedByType = allSpecializedMethodsOfInterfaces.GroupBy(m => m.DeclaringType);
if (concurrent)
{
Parallel.ForEach(
allSpecializedMethodsOfInterfacesGroupedByType,
specializedTypeMethods =>
DiscoverAllGenericMethodsOfInterfacesForMethod(
allTypes,
specializedTypeMethods,
readingTypesContext));
}
else
{
foreach (var specializedTypeMethods in allSpecializedMethodsOfInterfacesGroupedByType)
{
DiscoverAllGenericMethodsOfInterfacesForMethod(
allTypes,
specializedTypeMethods,
readingTypesContext);
}
}
}
private static void ReadingTypes(
IlReader ilReader,
string[] filter,
out IList <IType> usedTypes,
out IDictionary <IType, IEnumerable <IMethod> > genericMethodSpecializationsSorted)
{
// clean it as you are using IlReader
IlReader.GenericMethodSpecializations = null;
// types in current assembly
var readingTypesContext = ReadingTypesContext.New();
var types = ilReader.Types().Where(t => !t.IsGenericTypeDefinition);
if (filter != null)
{
types = types.Where(t => CheckFilter(filter, t));
}
var allTypes = ilReader.AllTypes().ToList();
// TODO: temp hack to initialize ThisType for TypeResolver
_codeWriter.Initialize(allTypes.First());
usedTypes = FindUsedTypes(types.ToList(), allTypes, readingTypesContext);
genericMethodSpecializationsSorted = GroupGenericMethodsByType(readingTypesContext.GenericMethodSpecializations);
Debug.Assert(usedTypes.All(t => !t.IsByRef), "Type is used with flag IsByRef");
}
/// <summary>
/// </summary>
/// <param name="type">
/// </param>
/// <param name="genericTypeSpecializations">
/// </param>
/// <param name="genericMethodSpecializations">
/// </param>
/// <returns>
/// </returns>
private static IEnumerable <IType> GetAllRequiredTypesForType(
IType typeSource,
ReadingTypesContext readingTypesContext)
{
Debug.Assert(typeSource != null, "Type is null");
if (typeSource.RequiredTypes != null)
{
return(typeSource.RequiredTypes);
}
lock (cachedRequiredTypes)
{
IEnumerable <IType> cachedQuery;
if (cachedRequiredTypes.TryGetValue(typeSource, out cachedQuery))
{
return(cachedQuery);
}
}
var query = IterateAllRequiredTypes(typeSource, readingTypesContext).ToList();
typeSource.RequiredTypes = query;
lock (cachedRequiredTypes)
{
if (!cachedRequiredTypes.ContainsKey(typeSource))
{
cachedRequiredTypes.Add(typeSource, query);
}
}
return(query);
}
private static IEnumerable <IType> IterateAllRequiredTypes(IType type, ReadingTypesContext readingTypesContext)
{
Debug.Assert(type != null, "Type is null");
if (type.BaseType != null)
{
DicoverGenericSpecializedTypesAndAdditionalTypes(type.BaseType, readingTypesContext);
yield return(type.BaseType);
}
if (type.HasElementType)
{
DicoverGenericSpecializedTypesAndAdditionalTypes(type.GetElementType(), readingTypesContext);
yield return(type.GetElementType());
}
var interfaces = type.GetInterfaces();
if (interfaces != null)
{
foreach (var @interface in interfaces)
{
DicoverGenericSpecializedTypesAndAdditionalTypes(@interface, readingTypesContext);
yield return(@interface);
}
}
if (!type.IsInterface)
{
var fields = IlReader.Fields(
type, BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance, _codeWriter);
foreach (var field in fields)
{
////#if DEBUG
//// Debug.WriteLine("Processing field: {0}, Type: {1}", field.FullName, field.FieldType);
////#endif
DicoverGenericSpecializedTypesAndAdditionalTypes(field.FieldType, readingTypesContext);
if (field.FieldType.IsStructureType() && !field.FieldType.IsPointer)
{
yield return(field.FieldType);
}
}
var ctors = IlReader.Constructors(
type, BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance, _codeWriter);
foreach (var requiredType in ctors.SelectMany(ctor => GetAllRequiredTypesForMethod(ctor, readingTypesContext)))
{
yield return(requiredType);
}
}
var methods = IlReader.Methods(
type, BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance, _codeWriter);
foreach (var requiredType in methods.SelectMany(method => GetAllRequiredTypesForMethod(method, readingTypesContext)))
{
yield return(requiredType);
}
}
/// <summary>
/// </summary>
/// <param name="type">
/// </param>
/// <param name="genericSpecializations">
/// </param>
/// <param name="genericMethodSpecializations">
/// </param>
private static void DicoverGenericSpecializedTypesAndAdditionalTypes(
IType typeSource,
ReadingTypesContext readingTypesContext)
{
Debug.Assert(typeSource != null, "Type is null");
if (typeSource == null)
{
return;
}
var type = typeSource.NormalizeType();
if (!readingTypesContext.ProcessedTypes.Add(type))
{
return;
}
var additionalTypesToProcess = readingTypesContext.AdditionalTypesToProcess;
var genericSpecializations = readingTypesContext.GenericTypeSpecializations;
var genericMethodSpecializations = readingTypesContext.GenericMethodSpecializations;
if (additionalTypesToProcess != null && !type.IsGenericTypeDefinition && type.IsArray)
{
additionalTypesToProcess.Add(type);
}
if (genericSpecializations == null && genericMethodSpecializations == null)
{
return;
}
if (type.HasElementType)
{
DicoverGenericSpecializedTypesAndAdditionalTypes(type.GetElementType(), readingTypesContext);
}
var isGenericToDiscover = type.IsGenericType && !type.IsGenericTypeDefinition && !TypeHasGenericParameter(type) && !TypeHasGenericParameterInGenericArguments(type);
if (isGenericToDiscover)
{
var bareType = type.ToBareType().ToNormal();
if (genericSpecializations == null || genericSpecializations.Add(bareType))
{
// todo the same for base class and interfaces
foreach (var item in GetAllRequiredTypesForType(type, readingTypesContext))
{
}
}
}
if (type.IsArray)
{
foreach (var item in GetAllRequiredTypesForType(type, readingTypesContext))
{
}
}
}
public static ReadingTypesContext New()
{
var context = new ReadingTypesContext();
context.GenericTypeSpecializations = new NamespaceContainer <IType>();
context.GenericMethodSpecializations = new NamespaceContainer <IMethod>();
context.AdditionalTypesToProcess = new NamespaceContainer <IType>();
context.ProcessedTypes = new NamespaceContainer <IType>();
return(context);
}
private static IEnumerable <IType> GetAllRequiredTypesForMethod(
IMethod method,
ReadingTypesContext readingTypesContext)
{
DicoverGenericSpecializedTypesAndAdditionalTypes(
method.ReturnType,
readingTypesContext);
foreach (var param in method.GetParameters())
{
DicoverGenericSpecializedTypesAndAdditionalTypes(
param.ParameterType,
readingTypesContext);
}
if (method.DeclaringType.IsInterface)
{
yield break;
}
var methodWithCustomBodyOrDefault = MethodBodyBank.GetMethodWithCustomBodyOrDefault(method, _codeWriter);
var methodBody = methodWithCustomBodyOrDefault.GetMethodBody(MetadataGenericContext.DiscoverFrom(method));
if (methodBody != null)
{
foreach (var localVar in methodBody.LocalVariables)
{
DicoverGenericSpecializedTypesAndAdditionalTypes(
localVar.LocalType,
readingTypesContext);
if (localVar.LocalType.IsStructureType() && !localVar.LocalType.IsPointer && !localVar.LocalType.IsByRef)
{
yield return(localVar.LocalType);
}
}
var usedStructTypes = new NamespaceContainer <IType>();
methodWithCustomBodyOrDefault.DiscoverRequiredTypesAndMethodsInMethodBody(
readingTypesContext.GenericTypeSpecializations,
readingTypesContext.GenericMethodSpecializations,
usedStructTypes,
readingTypesContext.AdditionalTypesToProcess,
new Queue <IMethod>());
foreach (var usedStructType in usedStructTypes)
{
yield return(usedStructType);
}
}
}
/// <summary>
/// </summary>
/// <param name="type">
/// </param>
/// <param name="typesAdded">
/// </param>
/// <param name="addedRequiredTypes">
/// </param>
/// <param name="genericTypeSpecializations">
/// </param>
/// <param name="genericMethodSpecializations">
/// </param>
private static void AppendRequiredTypesForType(
IType type,
IList <IType> addedRequiredTypes,
ReadingTypesContext readingTypesContext)
{
Debug.Assert(type != null, "Type is null");
var requiredTypes = GetAllRequiredTypesForType(type, readingTypesContext);
foreach (var requiredType in requiredTypes)
{
addedRequiredTypes.Add(requiredType);
}
addedRequiredTypes.Remove(type);
}
/// <summary>
/// </summary>
/// <param name="types">
/// </param>
/// <param name="typesAdded">
/// </param>
/// <param name="newListOfITypes">
/// </param>
/// <param name="genericSpecializations">
/// </param>
/// <param name="genericMethodSpecializations">
/// </param>
public static void ProcessRequiredITypesForITypes(
IEnumerable <IType> types,
INamespaceContainer <IType> newListOfITypes,
ReadingTypesContext readingTypesContext)
{
if (concurrent)
{
Parallel.ForEach(types, type => AppendRequiredTypesForType(type, newListOfITypes, readingTypesContext));
}
else
{
foreach (var type in types)
{
AppendRequiredTypesForType(type, newListOfITypes, readingTypesContext);
}
}
}
/// <summary>
/// </summary>
/// <param name="allTypes">
/// </param>
/// <param name="genericMethodSpecializations">
/// </param>
private static void DiscoverAllGenericVirtualMethods(
IEnumerable <IType> allTypes,
ReadingTypesContext readingTypesContext)
{
var genericMethodSpecializations = readingTypesContext.GenericMethodSpecializations;
// find all override of generic methods
var flags = BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static |
BindingFlags.Instance;
var overrideSpecializedMethods = new List <IMethod>();
foreach (
var overrideGenericMethod in
allTypes.SelectMany(
t => t.GetMethods(flags).Where(m => m.IsOverride && m.IsGenericMethodDefinition)))
{
var method = overrideGenericMethod;
var methodDefinition = overrideGenericMethod;
overrideSpecializedMethods.AddRange(
from methodSpecialization in
genericMethodSpecializations.Where(m => m.IsVirtual || m.IsOverride || m.IsAbstract)
where
method.DeclaringType.IsDerivedFrom(methodSpecialization.DeclaringType) &&
method.IsMatchingOverride(methodSpecialization)
select
methodDefinition.ToSpecialization(
MetadataGenericContext.CreateCustomMap(null, methodSpecialization, methodDefinition)));
}
// append to discovered
foreach (var overrideSpecializedMethod in overrideSpecializedMethods)
{
genericMethodSpecializations.Add(overrideSpecializedMethod);
// rediscover generic methods again
overrideSpecializedMethod.DiscoverRequiredTypesAndMethodsInMethodBody(
readingTypesContext.GenericTypeSpecializations,
readingTypesContext.GenericMethodSpecializations,
null,
readingTypesContext.AdditionalTypesToProcess,
new Queue <IMethod>());
}
}
private static void DiscoverAllGenericMethodsOfInterfacesForMethod(
IEnumerable <IType> allTypes,
IGrouping <IType, IMethod> specializedTypeMethods,
ReadingTypesContext readingTypesContext)
{
var types = allTypes.Where(t => t.GetAllInterfaces().Contains(specializedTypeMethods.Key)).ToList();
foreach (var interfaceMethodSpecialization in specializedTypeMethods)
{
var flags = BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance;
foreach (var classMethodDefinition in
types.SelectMany(
t =>
t.GetMethods(flags)
.Where(m => m.IsGenericMethodDefinition && m.IsMatchingOverride(interfaceMethodSpecialization))))
{
// find interface
var @interfaceDefinition =
classMethodDefinition.DeclaringType.GetInterfaces()
.First(i => i.TypeEquals(interfaceMethodSpecialization.DeclaringType));
var @interfaceMethodDefinition = @interfaceDefinition.GetMethods(flags)
.First(m => m.IsGenericMethodDefinition && m.IsMatchingOverride(interfaceMethodSpecialization));
var classMethodSpecialization =
classMethodDefinition.ToSpecialization(
MetadataGenericContext.CreateCustomMap(@interfaceMethodDefinition, interfaceMethodSpecialization, classMethodDefinition));
readingTypesContext.GenericMethodSpecializations.Add(classMethodSpecialization);
// rediscover generic methods again
classMethodSpecialization.DiscoverRequiredTypesAndMethodsInMethodBody(
readingTypesContext.GenericTypeSpecializations,
readingTypesContext.GenericMethodSpecializations,
null,
readingTypesContext.AdditionalTypesToProcess,
new Queue <IMethod>());
}
}
}
private static void AppendTypeWithRequiredTypePair(IType type, IList<IType> requiredTypesByType, ReadingTypesContext readingTypesContext)
{
if (VerboseOutput)
{
Trace.WriteLine(string.Format("Reading info about type: {0}", type));
}
GetAllRequiredTypesForType(type, readingTypesContext);
requiredTypesByType.Add(type);
}
/// <summary>
/// </summary>
/// <param name="allTypes">
/// </param>
/// <param name="genericMethodSpecializations">
/// </param>
private static void DiscoverAllGenericMethodsOfInterfaces(
IEnumerable<IType> allTypes,
ReadingTypesContext readingTypesContext)
{
var genericMethodSpecializations = readingTypesContext.GenericMethodSpecializations;
var allSpecializedMethodsOfInterfaces = genericMethodSpecializations.Where(m => m.DeclaringType.IsInterface && m.IsGenericMethod).Distinct().ToList();
var allSpecializedMethodsOfInterfacesGroupedByType = allSpecializedMethodsOfInterfaces.GroupBy(m => m.DeclaringType);
if (concurrent)
{
Parallel.ForEach(
allSpecializedMethodsOfInterfacesGroupedByType,
specializedTypeMethods =>
DiscoverAllGenericMethodsOfInterfacesForMethod(
allTypes,
specializedTypeMethods,
readingTypesContext));
}
else
{
foreach (var specializedTypeMethods in allSpecializedMethodsOfInterfacesGroupedByType)
{
DiscoverAllGenericMethodsOfInterfacesForMethod(
allTypes,
specializedTypeMethods,
readingTypesContext);
}
}
}
private static void DiscoverAllGenericMethodsOfInterfacesForMethod(
IEnumerable<IType> allTypes,
IGrouping<IType, IMethod> specializedTypeMethods,
ReadingTypesContext readingTypesContext)
{
var types = allTypes.Where(t => t.GetAllInterfaces().Contains(specializedTypeMethods.Key)).ToList();
foreach (var interfaceMethodSpecialization in specializedTypeMethods)
{
var flags = BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance;
foreach (var classMethodDefinition in
types.SelectMany(
t =>
t.GetMethods(flags)
.Where(m => m.IsGenericMethodDefinition && m.IsMatchingOverride(interfaceMethodSpecialization))))
{
// find interface
var @interfaceDefinition =
classMethodDefinition.DeclaringType.GetInterfaces()
.First(i => i.TypeEquals(interfaceMethodSpecialization.DeclaringType));
var @interfaceMethodDefinition = @interfaceDefinition.GetMethods(flags)
.First(m => m.IsGenericMethodDefinition && m.IsMatchingOverride(interfaceMethodSpecialization));
var classMethodSpecialization =
classMethodDefinition.ToSpecialization(
MetadataGenericContext.CreateCustomMap(@interfaceMethodDefinition, interfaceMethodSpecialization, classMethodDefinition));
readingTypesContext.GenericMethodSpecializations.Add(classMethodSpecialization);
// rediscover generic methods again
classMethodSpecialization.DiscoverRequiredTypesAndMethodsInMethodBody(
readingTypesContext.GenericTypeSpecializations,
readingTypesContext.GenericMethodSpecializations,
null,
readingTypesContext.AdditionalTypesToProcess,
new Queue<IMethod>());
}
}
}
/// <summary>
/// </summary>
/// <param name="type">
/// </param>
/// <param name="genericTypeSpecializations">
/// </param>
/// <param name="genericMethodSpecializations">
/// </param>
/// <returns>
/// </returns>
private static IEnumerable<IType> GetAllRequiredTypesForType(
IType typeSource,
ReadingTypesContext readingTypesContext)
{
Debug.Assert(typeSource != null, "Type is null");
if (typeSource.RequiredTypes != null)
{
return typeSource.RequiredTypes;
}
lock (cachedRequiredTypes)
{
IEnumerable<IType> cachedQuery;
if (cachedRequiredTypes.TryGetValue(typeSource, out cachedQuery))
{
return cachedQuery;
}
}
var query = IterateAllRequiredTypes(typeSource, readingTypesContext).ToList();
typeSource.RequiredTypes = query;
lock (cachedRequiredTypes)
{
if (!cachedRequiredTypes.ContainsKey(typeSource))
{
cachedRequiredTypes.Add(typeSource, query);
}
}
return query;
}
/// <summary>
/// </summary>
/// <param name="allTypes">
/// </param>
/// <param name="genericMethodSpecializations">
/// </param>
private static void DiscoverAllGenericVirtualMethods(
IEnumerable<IType> allTypes,
ReadingTypesContext readingTypesContext)
{
var genericMethodSpecializations = readingTypesContext.GenericMethodSpecializations;
// find all override of generic methods
var flags = BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static |
BindingFlags.Instance;
var overrideSpecializedMethods = new List<IMethod>();
foreach (
var overrideGenericMethod in
allTypes.SelectMany(
t => t.GetMethods(flags).Where(m => m.IsOverride && m.IsGenericMethodDefinition)))
{
var method = overrideGenericMethod;
var methodDefinition = overrideGenericMethod;
overrideSpecializedMethods.AddRange(
from methodSpecialization in
genericMethodSpecializations.Where(m => m.IsVirtual || m.IsOverride || m.IsAbstract)
where
method.DeclaringType.IsDerivedFrom(methodSpecialization.DeclaringType) &&
method.IsMatchingOverride(methodSpecialization)
select
methodDefinition.ToSpecialization(
MetadataGenericContext.CreateCustomMap(null, methodSpecialization, methodDefinition)));
}
// append to discovered
foreach (var overrideSpecializedMethod in overrideSpecializedMethods)
{
genericMethodSpecializations.Add(overrideSpecializedMethod);
// rediscover generic methods again
overrideSpecializedMethod.DiscoverRequiredTypesAndMethodsInMethodBody(
readingTypesContext.GenericTypeSpecializations,
readingTypesContext.GenericMethodSpecializations,
null,
readingTypesContext.AdditionalTypesToProcess,
new Queue<IMethod>());
}
}
/// <summary>
/// </summary>
/// <param name="type">
/// </param>
/// <param name="genericSpecializations">
/// </param>
/// <param name="genericMethodSpecializations">
/// </param>
private static void DicoverGenericSpecializedTypesAndAdditionalTypes(
IType typeSource,
ReadingTypesContext readingTypesContext)
{
Debug.Assert(typeSource != null, "Type is null");
if (typeSource == null)
{
return;
}
var type = typeSource.NormalizeType();
if (!readingTypesContext.ProcessedTypes.Add(type))
{
return;
}
var additionalTypesToProcess = readingTypesContext.AdditionalTypesToProcess;
var genericSpecializations = readingTypesContext.GenericTypeSpecializations;
var genericMethodSpecializations = readingTypesContext.GenericMethodSpecializations;
if (additionalTypesToProcess != null && !type.IsGenericTypeDefinition && type.IsArray)
{
additionalTypesToProcess.Add(type);
}
if (genericSpecializations == null && genericMethodSpecializations == null)
{
return;
}
if (type.HasElementType)
{
DicoverGenericSpecializedTypesAndAdditionalTypes(type.GetElementType(), readingTypesContext);
}
var isGenericToDiscover = type.IsGenericType && !type.IsGenericTypeDefinition && !TypeHasGenericParameter(type) && !TypeHasGenericParameterInGenericArguments(type);
if (isGenericToDiscover)
{
var bareType = type.ToBareType().ToNormal();
if (genericSpecializations == null || genericSpecializations.Add(bareType))
{
// todo the same for base class and interfaces
foreach (var item in GetAllRequiredTypesForType(type, readingTypesContext))
{
}
}
}
if (type.IsArray)
{
foreach (var item in GetAllRequiredTypesForType(type, readingTypesContext))
{
}
}
}
private static IEnumerable<IType> IterateAllRequiredTypes(IType type, ReadingTypesContext readingTypesContext)
{
Debug.Assert(type != null, "Type is null");
if (type.BaseType != null)
{
DicoverGenericSpecializedTypesAndAdditionalTypes(type.BaseType, readingTypesContext);
yield return type.BaseType;
}
if (type.HasElementType)
{
DicoverGenericSpecializedTypesAndAdditionalTypes(type.GetElementType(), readingTypesContext);
yield return type.GetElementType();
}
var interfaces = type.GetInterfaces();
if (interfaces != null)
{
foreach (var @interface in interfaces)
{
DicoverGenericSpecializedTypesAndAdditionalTypes(@interface, readingTypesContext);
yield return @interface;
}
}
if (!type.IsInterface)
{
var fields = IlReader.Fields(
type, BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance, _codeWriter);
foreach (var field in fields)
{
////#if DEBUG
//// Debug.WriteLine("Processing field: {0}, Type: {1}", field.FullName, field.FieldType);
////#endif
DicoverGenericSpecializedTypesAndAdditionalTypes(field.FieldType, readingTypesContext);
if (field.FieldType.IsStructureType() && !field.FieldType.IsPointer)
{
yield return field.FieldType;
}
}
var ctors = IlReader.Constructors(
type, BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance, _codeWriter);
foreach (var requiredType in ctors.SelectMany(ctor => GetAllRequiredTypesForMethod(ctor, readingTypesContext)))
{
yield return requiredType;
}
}
var methods = IlReader.Methods(
type, BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance, _codeWriter);
foreach (var requiredType in methods.SelectMany(method => GetAllRequiredTypesForMethod(method, readingTypesContext)))
{
yield return requiredType;
}
}
private static IEnumerable<IType> GetAllRequiredTypesForMethod(
IMethod method,
ReadingTypesContext readingTypesContext)
{
DicoverGenericSpecializedTypesAndAdditionalTypes(
method.ReturnType,
readingTypesContext);
foreach (var param in method.GetParameters())
{
DicoverGenericSpecializedTypesAndAdditionalTypes(
param.ParameterType,
readingTypesContext);
}
if (method.DeclaringType.IsInterface)
{
yield break;
}
var methodWithCustomBodyOrDefault = MethodBodyBank.GetMethodWithCustomBodyOrDefault(method, _codeWriter);
var methodBody = methodWithCustomBodyOrDefault.GetMethodBody(MetadataGenericContext.DiscoverFrom(method));
if (methodBody != null)
{
foreach (var localVar in methodBody.LocalVariables)
{
DicoverGenericSpecializedTypesAndAdditionalTypes(
localVar.LocalType,
readingTypesContext);
if (localVar.LocalType.IsStructureType() && !localVar.LocalType.IsPointer && !localVar.LocalType.IsByRef)
{
yield return localVar.LocalType;
}
}
var usedStructTypes = new NamespaceContainer<IType>();
methodWithCustomBodyOrDefault.DiscoverRequiredTypesAndMethodsInMethodBody(
readingTypesContext.GenericTypeSpecializations,
readingTypesContext.GenericMethodSpecializations,
usedStructTypes,
readingTypesContext.AdditionalTypesToProcess,
new Queue<IMethod>());
foreach (var usedStructType in usedStructTypes)
{
yield return usedStructType;
}
}
}
/// <summary>
/// </summary>
/// <param name="genericTypeSpecializations">
/// </param>
/// <param name="requiredTypes">
/// </param>
private static void ProcessGenericTypesAndAdditionalTypesToFindRequiredTypes(
IList<IType> requiredTypes,
ReadingTypesContext readingTypesContext,
bool applyConccurent = false)
{
var subSetGenericTypeSpecializations = new NamespaceContainer<IType>();
var subSetAdditionalTypesToProcess = new NamespaceContainer<IType>();
var subSetReadingContext = new ReadingTypesContext();
subSetReadingContext.GenericTypeSpecializations = subSetGenericTypeSpecializations;
subSetReadingContext.GenericMethodSpecializations = readingTypesContext.GenericMethodSpecializations;
subSetReadingContext.AdditionalTypesToProcess = subSetAdditionalTypesToProcess;
subSetReadingContext.ProcessedTypes = readingTypesContext.ProcessedTypes;
// the same for generic specialized types
if (concurrent && applyConccurent)
{
Parallel.ForEach(
readingTypesContext.GenericTypeSpecializations.ToList(),
type => AppendTypeWithRequiredTypePair(type, requiredTypes, subSetReadingContext));
Parallel.ForEach(
readingTypesContext.AdditionalTypesToProcess.ToList(),
type => AppendTypeWithRequiredTypePair(type, requiredTypes, subSetReadingContext));
}
else
{
foreach (var type in readingTypesContext.GenericTypeSpecializations.ToList())
{
Debug.Assert(type != null);
if (type == null)
{
continue;
}
AppendTypeWithRequiredTypePair(type, requiredTypes, subSetReadingContext);
}
foreach (var type in readingTypesContext.AdditionalTypesToProcess.ToList())
{
Debug.Assert(type != null);
if (type == null)
{
continue;
}
AppendTypeWithRequiredTypePair(type, requiredTypes, subSetReadingContext);
}
}
if (subSetGenericTypeSpecializations.Count > 0 || subSetAdditionalTypesToProcess.Count > 0)
{
foreach (var discoveredType in requiredTypes)
{
subSetGenericTypeSpecializations.Remove(discoveredType);
}
foreach (var discoveredType in requiredTypes)
{
Debug.Assert(discoveredType != null);
subSetAdditionalTypesToProcess.Remove(discoveredType);
}
ProcessGenericTypesAndAdditionalTypesToFindRequiredTypes(requiredTypes, subSetReadingContext);
// join types
foreach (var discoveredType in subSetGenericTypeSpecializations)
{
Debug.Assert(discoveredType != null);
readingTypesContext.GenericTypeSpecializations.Add(discoveredType);
}
// join types
foreach (var discoveredType in subSetAdditionalTypesToProcess)
{
Debug.Assert(discoveredType != null);
readingTypesContext.AdditionalTypesToProcess.Add(discoveredType);
}
}
}
/// <summary>
/// </summary>
/// <param name="type">
/// </param>
/// <param name="typesAdded">
/// </param>
/// <param name="addedRequiredTypes">
/// </param>
/// <param name="genericTypeSpecializations">
/// </param>
/// <param name="genericMethodSpecializations">
/// </param>
private static void AppendRequiredTypesForType(
IType type,
IList<IType> addedRequiredTypes,
ReadingTypesContext readingTypesContext)
{
Debug.Assert(type != null, "Type is null");
var requiredTypes = GetAllRequiredTypesForType(type, readingTypesContext);
foreach (var requiredType in requiredTypes)
{
addedRequiredTypes.Add(requiredType);
}
addedRequiredTypes.Remove(type);
}
/// <summary>
/// </summary>
/// <param name="genericTypeSpecializations">
/// </param>
/// <param name="requiredTypes">
/// </param>
private static void ProcessGenericTypesAndAdditionalTypesToFindRequiredTypes(
IList <IType> requiredTypes,
ReadingTypesContext readingTypesContext,
bool applyConccurent = false)
{
var subSetGenericTypeSpecializations = new NamespaceContainer <IType>();
var subSetAdditionalTypesToProcess = new NamespaceContainer <IType>();
var subSetReadingContext = new ReadingTypesContext();
subSetReadingContext.GenericTypeSpecializations = subSetGenericTypeSpecializations;
subSetReadingContext.GenericMethodSpecializations = readingTypesContext.GenericMethodSpecializations;
subSetReadingContext.AdditionalTypesToProcess = subSetAdditionalTypesToProcess;
subSetReadingContext.ProcessedTypes = readingTypesContext.ProcessedTypes;
// the same for generic specialized types
if (concurrent && applyConccurent)
{
Parallel.ForEach(
readingTypesContext.GenericTypeSpecializations.ToList(),
type => AppendTypeWithRequiredTypePair(type, requiredTypes, subSetReadingContext));
Parallel.ForEach(
readingTypesContext.AdditionalTypesToProcess.ToList(),
type => AppendTypeWithRequiredTypePair(type, requiredTypes, subSetReadingContext));
}
else
{
foreach (var type in readingTypesContext.GenericTypeSpecializations.ToList())
{
Debug.Assert(type != null);
if (type == null)
{
continue;
}
AppendTypeWithRequiredTypePair(type, requiredTypes, subSetReadingContext);
}
foreach (var type in readingTypesContext.AdditionalTypesToProcess.ToList())
{
Debug.Assert(type != null);
if (type == null)
{
continue;
}
AppendTypeWithRequiredTypePair(type, requiredTypes, subSetReadingContext);
}
}
if (subSetGenericTypeSpecializations.Count > 0 || subSetAdditionalTypesToProcess.Count > 0)
{
foreach (var discoveredType in requiredTypes)
{
subSetGenericTypeSpecializations.Remove(discoveredType);
}
foreach (var discoveredType in requiredTypes)
{
Debug.Assert(discoveredType != null);
subSetAdditionalTypesToProcess.Remove(discoveredType);
}
ProcessGenericTypesAndAdditionalTypesToFindRequiredTypes(requiredTypes, subSetReadingContext);
// join types
foreach (var discoveredType in subSetGenericTypeSpecializations)
{
Debug.Assert(discoveredType != null);
readingTypesContext.GenericTypeSpecializations.Add(discoveredType);
}
// join types
foreach (var discoveredType in subSetAdditionalTypesToProcess)
{
Debug.Assert(discoveredType != null);
readingTypesContext.AdditionalTypesToProcess.Add(discoveredType);
}
}
}
/// <summary>
/// </summary>
/// <param name="types">
/// </param>
/// <param name="typesAdded">
/// </param>
/// <param name="newListOfITypes">
/// </param>
/// <param name="genericSpecializations">
/// </param>
/// <param name="genericMethodSpecializations">
/// </param>
public static void ProcessRequiredITypesForITypes(
IEnumerable<IType> types,
INamespaceContainer<IType> newListOfITypes,
ReadingTypesContext readingTypesContext)
{
if (concurrent)
{
Parallel.ForEach(types, type => AppendRequiredTypesForType(type, newListOfITypes, readingTypesContext));
}
else
{
foreach (var type in types)
{
AppendRequiredTypesForType(type, newListOfITypes, readingTypesContext);
}
}
}
private static void AppendTypeWithRequiredTypePair(IType type, IList <IType> requiredTypesByType, ReadingTypesContext readingTypesContext)
{
if (VerboseOutput)
{
Trace.WriteLine(string.Format("Reading info about type: {0}", type));
}
GetAllRequiredTypesForType(type, readingTypesContext);
requiredTypesByType.Add(type);
}
/// <summary>
/// </summary>
/// <param name="types">
/// </param>
/// <param name="genericTypeSpecializations">
/// </param>
/// <param name="genericMethodSpecializations">
/// </param>
/// <returns>
/// </returns>
private static IList<IType> FindUsedTypes(IEnumerable<IType> types, IList<IType> allTypes, ReadingTypesContext readingTypesContext)
{
var usedTypes = new NamespaceContainer<IType>();
if (concurrent)
{
Parallel.ForEach(types, type => AppendTypeWithRequiredTypePair(type, usedTypes, readingTypesContext));
}
else
{
foreach (var type in types)
{
AppendTypeWithRequiredTypePair(type, usedTypes, readingTypesContext);
}
}
ProcessGenericTypesAndAdditionalTypesToFindRequiredTypes(usedTypes, readingTypesContext, true);
DiscoverAllGenericVirtualMethods(allTypes, readingTypesContext);
DiscoverAllGenericMethodsOfInterfaces(allTypes, readingTypesContext);
return usedTypes;
}
/// <summary>
/// </summary>
/// <param name="types">
/// </param>
/// <param name="genericTypeSpecializations">
/// </param>
/// <param name="genericMethodSpecializations">
/// </param>
/// <returns>
/// </returns>
private static IList <IType> FindUsedTypes(IEnumerable <IType> types, IList <IType> allTypes, ReadingTypesContext readingTypesContext)
{
var usedTypes = new NamespaceContainer <IType>();
if (concurrent)
{
Parallel.ForEach(types, type => AppendTypeWithRequiredTypePair(type, usedTypes, readingTypesContext));
}
else
{
foreach (var type in types)
{
AppendTypeWithRequiredTypePair(type, usedTypes, readingTypesContext);
}
}
ProcessGenericTypesAndAdditionalTypesToFindRequiredTypes(usedTypes, readingTypesContext, true);
DiscoverAllGenericVirtualMethods(allTypes, readingTypesContext);
DiscoverAllGenericMethodsOfInterfaces(allTypes, readingTypesContext);
return(usedTypes);
}
public static ReadingTypesContext New()
{
var context = new ReadingTypesContext();
context.GenericTypeSpecializations = new NamespaceContainer<IType>();
context.GenericMethodSpecializations = new NamespaceContainer<IMethod>();
context.AdditionalTypesToProcess = new NamespaceContainer<IType>();
context.ProcessedTypes = new NamespaceContainer<IType>();
return context;
}
