public void BuildMethod(ILConversion conversion, ConvertedTypeWithMethods_I input, MethodDefinition method)
{
if (input.IsGeneric() && input is ConvertedGenericTypeDefinition_I generic && generic.IsClosedType())
{
return;
}
var methodEntry = new ConvertedBuiltMethod
{
MethodReference = method,
DeclaringType = input,
Conversion = conversion,
MethodAttributes = BuildMethodAttributes(method),
Name = method.Name
};
if (!input.Methods.ByName.TryGetValue(methodEntry.Name, out List <SemanticMethodMask_I> methods))
{
methods = new List <SemanticMethodMask_I>();
input.Methods.ByName.Add(methodEntry.Name, methods);
}
var callingConventions = Methods.GetCallingConventions(method);
methods.Add(methodEntry);
input.Routines.Add(methodEntry);
methodEntry.MethodBuilder = input.TypeBuilder.DefineMethod(method.Name, methodEntry.MethodAttributes, callingConventions);
// Needs method builder to create the generic parameters
AddGenericParameters(conversion, input, methodEntry);
var systemParameterTypes = Routines.Building.CreateParameters(conversion, methodEntry);
var systemReturnType = Routines.Building.SetReturnType(conversion, methodEntry);
methodEntry.MethodBuilder.SetSignature(systemReturnType, Type.EmptyTypes, Type.EmptyTypes, systemParameterTypes, null, null);
// The 'CreateParameterBuilder' call has to called after the parameters are defined
// in the define constructor call. Thus a second loop is needed.
Routines.Building.CreateParameterBuilders(conversion, methodEntry);
BuildBody(conversion, method, methodEntry);
SetImplementationFlagsIfPresent(method, methodEntry.MethodBuilder);
CustomAttributes.BuildCustomAttributes(conversion, input, methodEntry);
if (method.MethodReturnType.HasCustomAttributes)
{
var returnParameter = methodEntry.MethodBuilder.DefineParameter(0, System.Reflection.ParameterAttributes.Retval, null);
CustomAttributes.BuildCustomAttributes(conversion, returnParameter, method.MethodReturnType);
}
}
[Obsolete] //?
public BoundTypeMask_I[] GetParameterTypes(ILConversion conversion, ConvertedBuiltMethod methodEntry)
{
var methodDefinition = methodEntry.MethodReference;
if (methodDefinition.HasParameters)
{
List <BoundTypeMask_I> parameterTypeList = new List <BoundTypeMask_I>();
foreach (var parameterDefinition in methodDefinition.Parameters)
{
var parameterType = Execution.Types.Ensuring.EnsureBound(conversion, parameterDefinition.ParameterType);
parameterTypeList.Add(parameterType);
}
return(parameterTypeList.ToArray());
}
return(new BoundTypeMask_I[0]);
}
public ConvertedGenericParameterTypeDefinition_I GetOrThrow(ILConversion conversion, ConvertedBuiltMethod method, int position)
{
return(Members.TypeParameters.GetOrThrow(conversion, method.TypeParameters, position));
}
public string[] GetNames(ILConversion conversion, ConvertedBuiltMethod method)
{
return(Members.TypeParameters.GetNames(conversion, method.TypeParameters));
}
public ConvertedGenericParameterTypeDefinition_I Get(ILConversion conversion, ConvertedBuiltMethod method, string name)
{
return(Members.TypeParameters.Get(conversion, method.TypeParameters, name));
}
public void Clear(ILConversion conversion, ConvertedBuiltMethod method)
{
Members.TypeParameters.Clear(conversion, method.TypeParameters);
}
public void Add(ILConversion conversion, ConvertedBuiltMethod method, List <ConvertedGenericParameterTypeDefinition> typeParameters)
{
Members.TypeParameters.Add(conversion, method.TypeParameters, typeParameters);
}
public void AddGenericParameters(ILConversion conversion, ConvertedTypeDefinitionMask_I input, ConvertedBuiltMethod methodEntry)
{
var methodDefinition = methodEntry.MethodReference;
if (!methodDefinition.HasGenericParameters)
{
return;
}
List <string> genericParameterNamesList = new List <string>();
foreach (var parameter in methodDefinition.GenericParameters)
{
var genericParamaterTypeDefintionEntry = new ConvertedGenericParameterTypeDefinition()
{
Attributes = Cecil.Metadata.Members.GenericParameters.GetTypeParameterAttributes(parameter),
Name = parameter.Name,
FullName = parameter.FullName,
Position = parameter.Position,
TypeParameterKind = GetTypeParameterKind(parameter.Type),
Definition = parameter,
SourceTypeReference = parameter,
DeclaringTypeDefinitionEntry = methodEntry.DeclaringType,
ResolutionName = Cecil.Types.Naming.GetResolutionName(parameter)
};
genericParamaterTypeDefintionEntry.ConversionState.BuildPhase = BuildPhaseKind.TypeCreated;
genericParameterNamesList.Add(genericParamaterTypeDefintionEntry.Name);
Methods.TypeParameters.Add(conversion, methodEntry, genericParamaterTypeDefintionEntry);
}
var genericParameterNames = genericParameterNamesList.ToArray();
GenericTypeParameterBuilder[] genericTypeParameterBuilders = methodEntry.MethodBuilder.DefineGenericParameters(genericParameterNames);
methodEntry.TypeParameters.Builders = genericTypeParameterBuilders;
foreach (var builder in genericTypeParameterBuilders)
{
var name = builder.Name;
var genericTypeParameterEntry = Methods.TypeParameters.GetOrThrow(conversion, methodEntry, name);
var definition = genericTypeParameterEntry.Definition;
var attributes = GetGenericParameterAttributes(definition);
builder.SetGenericParameterAttributes(attributes);
genericTypeParameterEntry.Builder = builder;
if (definition.HasConstraints)
{
List <Type> interfaceConstraintTypes = new List <Type>();
foreach (var constraint in definition.Constraints)
{
bool isClassConstraint = Cecil.Types.IsClass(conversion.RuntimicSystem, constraint);
var semanticConstraint = Execution.Types.Ensuring.EnsureBound(conversion, constraint, null);
if (isClassConstraint)
{
builder.SetBaseTypeConstraint(semanticConstraint.UnderlyingType);
}
else
{
interfaceConstraintTypes.Add(semanticConstraint.UnderlyingType);
}
}
if (interfaceConstraintTypes.Count > 0)
{
builder.SetInterfaceConstraints(interfaceConstraintTypes.ToArray());
}
}
genericTypeParameterEntry.UnderlyingType = builder;
}
}
public void BuildBody(ILConversion conversion, MethodDefinition methodDefinition, ConvertedBuiltMethod methodEntry)
{
if (methodDefinition.HasBody)
{
methodEntry.Body = new ConvertedRoutineBody();
if (methodDefinition.Body.HasVariables)
{
methodEntry.Body.LocalVariables = new ConvertedRoutineLocalVariable[methodDefinition.Body.Variables.Count];
for (int i = 0; i < methodDefinition.Body.Variables.Count; i++)
{
var variable = methodDefinition.Body.Variables[i];
var variableTypeReference = variable.VariableType;
var variableType = Execution.Types.Ensuring.EnsureToType(conversion, variableTypeReference);
methodEntry.Body.LocalVariables[i] = new ConvertedRoutineLocalVariable()
{
IsPinned = variable.IsPinned,
UnderlyingType = variableType,
Index = variable.Index
};
}
}
}
}
public void BuildCustomAttributes(ILConversion conversion, ConvertedTypeWithMethods_I input, ConvertedBuiltMethod methodEntry)
{
var methodDefinition = (MethodDefinition)methodEntry.MethodReference;
var builders = CreateCustomAttributeList(conversion, methodDefinition.CustomAttributes);
for (int i = 0; i < builders.Count; i++)
{
var builder1 = builders[i];
methodEntry.MethodBuilder.SetCustomAttribute(builder1);
}
//builders = CreateCustomAttributeList(conversion, methodDefinition.MethodReturnType.CustomAttributes);
//for (int i = 0; i < builders.Count; i++)
//{
// var builder1 = builders[i];
//}
}
