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