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]; //} }