/// <summary>
/// </summary>
/// <param name="method">
/// </param>
/// <param name="genericTypeSpecializations">
/// </param>
/// <param name="genericMethodSpecializations">
/// </param>
/// <param name="structTypes">
/// </param>
/// <param name="stackCall">
/// </param>
public static void DiscoverRequiredTypesAndMethodsInMethodBody(
this IMethod method,
ISet <IType> genericTypeSpecializations,
ISet <IMethod> genericMethodSpecializations,
ISet <IType> structTypes,
ISet <IType> arrayTypes,
Queue <IMethod> stackCall)
{
if (Il2Converter.VerboseOutput)
{
Debug.WriteLine("Scanning method for types: {0}", method);
}
// read method body to extract all types
var reader = new IlReader();
reader.UsedStructTypes = structTypes;
reader.UsedArrayTypes = arrayTypes;
reader.UsedGenericSpecialiazedTypes = genericTypeSpecializations;
reader.UsedGenericSpecialiazedMethods = genericMethodSpecializations;
var genericContext = MetadataGenericContext.DiscoverFrom(method, false); // true
foreach (var op in reader.OpCodes(method, genericContext, stackCall))
{
}
}
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="method">
/// </param>
/// <param name="structTypes">
/// </param>
/// <param name="calledMethods">
/// </param>
/// <param name="readStaticFields">
/// </param>
public static void DiscoverMethod(this IMethod method, ISet <IType> structTypes, ISet <IMethod> calledMethods, ISet <IField> readStaticFields)
{
// read method body to extract all types
var reader = new IlReader();
reader.UsedTypes = structTypes;
reader.CalledMethods = calledMethods;
reader.UsedStaticFieldsToRead = readStaticFields;
var genericContext = MetadataGenericContext.DiscoverFrom(method);
foreach (var op in reader.OpCodes(method, genericContext, new Queue <IMethod>()))
{
}
}
/// <summary>
/// </summary>
/// <param name="method">
/// </param>
/// <param name="genericTypeSpecializations">
/// </param>
/// <param name="genericMethodSpecializations">
/// </param>
/// <param name="requiredTypes">
/// </param>
/// <param name="stackCall">
/// </param>
public static void DiscoverRequiredTypesAndMethodsInMethodBody(
this IMethod method,
ISet <IType> genericTypeSpecializations,
ISet <IMethod> genericMethodSpecializations,
ISet <IType> requiredTypes,
Queue <IMethod> stackCall)
{
// read method body to extract all types
var reader = new IlReader();
reader.UsedStructTypes = requiredTypes;
reader.UsedGenericSpecialiazedTypes = genericTypeSpecializations;
reader.UsedGenericSpecialiazedMethods = genericMethodSpecializations;
var genericContext = MetadataGenericContext.DiscoverFrom(method, false); // true
foreach (var op in reader.OpCodes(method, genericContext, stackCall))
{
}
}
/// <summary>
/// </summary>
/// <param name="type">
/// </param>
/// <param name="genericTypeSpecializations">
/// </param>
/// <param name="genericMethodSpecializations">
/// </param>
/// <returns>
/// </returns>
private static IEnumerable <IType> GetAllRequiredITypesForIType(
IType type, ISet <IType> genericTypeSpecializations, ISet <IMethod> genericMethodSpecializations)
{
Debug.Assert(type != null);
if (type.BaseType != null)
{
DicoverGenericSpecializedIType(type.BaseType, genericTypeSpecializations, genericMethodSpecializations);
yield return(type.BaseType);
}
var interfaces = type.GetInterfaces();
if (interfaces != null)
{
foreach (var @interface in interfaces)
{
DicoverGenericSpecializedIType(@interface, genericTypeSpecializations, genericMethodSpecializations);
yield return(@interface);
}
}
var fields = type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance);
if (fields != null)
{
foreach (var field in fields)
{
DicoverGenericSpecializedIType(field.FieldType, genericTypeSpecializations, genericMethodSpecializations);
if (field.FieldType.IsStructureType() && !field.FieldType.IsPointer)
{
yield return(field.FieldType);
}
}
}
var methods = type.GetMethods(
BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance);
if (methods != null)
{
foreach (var method in methods)
{
DicoverGenericSpecializedIType(method.ReturnType, genericTypeSpecializations, genericMethodSpecializations);
foreach (var param in method.GetParameters())
{
DicoverGenericSpecializedIType(param.ParameterType, genericTypeSpecializations, genericMethodSpecializations);
}
var methodBody = method.GetMethodBody(MetadataGenericContext.DiscoverFrom(method));
if (methodBody != null)
{
foreach (var localVar in methodBody.LocalVariables)
{
DicoverGenericSpecializedIType(localVar.LocalType, genericTypeSpecializations, genericMethodSpecializations);
if (localVar.LocalType.IsStructureType() && !localVar.LocalType.IsPointer)
{
yield return(localVar.LocalType);
}
}
var usedStructTypes = new HashSet <IType>();
method.DiscoverRequiredTypesAndMethodsInMethodBody(
genericTypeSpecializations, genericMethodSpecializations, usedStructTypes, new Queue <IMethod>());
foreach (var usedStructType in usedStructTypes)
{
yield return(usedStructType);
}
}
}
}
}
