| public DefineGenericParameters ( ) : System.Reflection.Emit.GenericTypeParameterBuilder[] | ||
| return | System.Reflection.Emit.GenericTypeParameterBuilder[] | |
public void SetupParameters(MethodBuilder methodBuilder)
{
if (methodToOverride.IsGenericMethod)
{
Type[] genericArguments = methodToOverride.GetGenericArguments();
string[] names = genericArguments
.Select(t => t.Name)
.ToArray();
GenericTypeParameterBuilder[] builders = methodBuilder.DefineGenericParameters(names);
for (int i = 0; i < genericArguments.Length; ++i)
{
builders[i].SetGenericParameterAttributes(genericArguments[i].GenericParameterAttributes);
var constraintTypes = genericArguments[i].GetGenericParameterConstraints();
builders[i].SetInterfaceConstraints(constraintTypes.Where(t => t.IsInterface).ToArray());
foreach (Type type in constraintTypes.Where(t => !t.IsInterface))
{
builders[i].SetBaseTypeConstraint(type);
}
}
for(int i = 0; i < genericArguments.Length; ++i)
{
genericMethodParameters.Add(new KeyValuePair<Type, Type>(genericArguments[i], builders[i].UnderlyingSystemType));
}
}
}
protected static GenericTypeParameterBuilder[] CloneGenericMethodArguments(MethodInfo source, MethodBuilder destination)
{
var genericArgs = source.GetGenericArguments();
if (genericArgs.Length == 0)
{
return new GenericTypeParameterBuilder[0];
}
var names = new string[genericArgs.Length];
for (var i = 0; i < genericArgs.Length; i++)
{
names[i] = genericArgs[i].Name;
}
var genericTypeParameterBuilders = destination.DefineGenericParameters(names);
for (var i = 0; i < genericTypeParameterBuilders.Length; i++)
{
var genericArgConstraints = genericArgs[i].GetGenericParameterConstraints();
for (var j = 0; j < genericArgConstraints.Length; j++)
{
genericTypeParameterBuilders[i].SetBaseTypeConstraint(genericArgConstraints[j]);
}
}
return genericTypeParameterBuilders;
}
public static GenericTypeParameterBuilder[] CopyGenericArguments(
MethodInfo methodToCopyGenericsFrom,
MethodBuilder builder,
Dictionary<String, GenericTypeParameterBuilder> name2GenericType)
{
return
CopyGenericArguments(methodToCopyGenericsFrom, name2GenericType,
delegate(String[] args) { return builder.DefineGenericParameters(args); });
}
public static GenericTypeParameterBuilder[] DefineGenericArguments(
Type[] genericArguments,
MethodBuilder builder,
Dictionary<String, GenericTypeParameterBuilder>
name2GenericType)
{
return
DefineGenericArguments(genericArguments, name2GenericType,
delegate(String[] args) { return builder.DefineGenericParameters(args); });
}
private static void CopyGenericMethodParameters(MethodInfo targetMethod,
MethodDefinition method,
Dictionary <Type, Type> genArgMapping,
Func <Type, Type> typeReplacer)
{
if (targetMethod.IsGenericMethodDefinition)
{
var targetGenArgs = targetMethod.GetGenericArguments();
var items =
method.DefineGenericParameters(targetGenArgs.Select(x => x.Name).ToArray()).Zip(targetGenArgs,
(paramBuilder,
target) =>
new
{
paramBuilder,
target
})
.ToList();
foreach (var arg in items)
{
arg.paramBuilder.SetGenericParameterAttributes(arg.target.GenericParameterAttributes);
genArgMapping[arg.target] = arg.paramBuilder;
}
foreach (var arg in items)
{
IEnumerable <Type> interfaceConstraints =
arg.target.GetGenericParameterConstraints().Select(typeReplacer).ToList();
if (arg.target.BaseType != null)
{
var baseTypeFixed = typeReplacer(arg.target.BaseType);
if (!baseTypeFixed.IsInterface)
{
arg.paramBuilder.SetBaseTypeConstraint(baseTypeFixed);
}
else
{
//arg.paramBuilder.SetBaseTypeConstraint(typeof(object));
interfaceConstraints = interfaceConstraints.Append(baseTypeFixed);
}
//if (arg.target.BaseType.IsGenericParameter)
//{
// interfaceConstraints = interfaceConstraints.Except(arg.target.BaseType.GetInterfaces());
//}
}
arg.paramBuilder.SetInterfaceConstraints(interfaceConstraints.ToArray());
}
}
}
/// <summary>
/// Copy the generic attributes of a method.
/// </summary>
/// <param name="sourceMethod">The source method.</param>
/// <param name="targetMethod">The target method.</param>
internal static void CopyGenericSignature(MethodInfo sourceMethod, MethodBuilder targetMethod)
{
if (sourceMethod.IsGenericMethod)
{
// get the interface's generic types and make our own
var oldTypes = sourceMethod.GetGenericArguments();
var newTypes = targetMethod.DefineGenericParameters(oldTypes.Select(t => t.Name).ToArray());
for (int i = 0; i < newTypes.Length; i++)
{
var oldType = oldTypes[i];
var newType = newTypes[i];
newType.SetGenericParameterAttributes(oldType.GenericParameterAttributes);
newType.SetInterfaceConstraints(oldType.GetGenericParameterConstraints());
}
}
}
public void SetupParameters(MethodBuilder methodBuilder, GenericParameterMapper parentMapper)
{
if (methodToOverride.IsGenericMethod)
{
var genericArguments = methodToOverride.GetGenericArguments();
var names = genericArguments.Select(t => t.Name).ToArray();
var builders = methodBuilder.DefineGenericParameters(names);
for (int i = 0; i < genericArguments.Length; ++i)
{
builders[i].SetGenericParameterAttributes(genericArguments[i].GenericParameterAttributes);
var constraintTypes =
genericArguments[i]
.GetGenericParameterConstraints()
.Select(ct => parentMapper.Map(ct))
.ToArray();
var interfaceConstraints = constraintTypes.Where(t => t.IsInterface).ToArray();
Type baseConstraint = constraintTypes.Where(t => !t.IsInterface).FirstOrDefault();
if (baseConstraint != null)
{
builders[i].SetBaseTypeConstraint(baseConstraint);
}
if (interfaceConstraints.Length > 0)
{
builders[i].SetInterfaceConstraints(interfaceConstraints);
}
}
this.genericParameterMapper =
new GenericParameterMapper(genericArguments, builders.Cast<Type>().ToArray(), parentMapper);
}
else
{
this.genericParameterMapper = parentMapper;
}
}
/// <summary>
/// Defines the generic parameters of an internal generic method.
/// </summary>
void DefineGenericParameters(MethodBuilder builder, GenericParameterDeclaration[] parameters)
{
string[] names = Array.ConvertAll<GenericParameterDeclaration, string>(
parameters,
delegate(GenericParameterDeclaration gpd) { return gpd.Name; });
GenericTypeParameterBuilder[] builders = builder.DefineGenericParameters(names);
DefineGenericParameters(builders, parameters);
}
private GenericTypeParameterBuilder[] DefineGenericParameters(TypeBuilder typeBuilder, MethodBuilder methodBuilder, IEnumerable<Cci.IGenericParameter> typeParameters)
{
Debug.Assert(typeBuilder != null ^ methodBuilder != null);
var names = new List<string>(typeParameters.Select(typeParameter => typeParameter.Name)).ToArray();
var gpBuilders = (typeBuilder != null) ? typeBuilder.DefineGenericParameters(names) : methodBuilder.DefineGenericParameters(names);
int i = 0;
foreach (var typeParameter in typeParameters)
{
_genericParameterBuilders.Add(typeParameter, gpBuilders[i++]);
}
return gpBuilders;
}
/// <summary>
/// Defines generic parameters according to the given template and re-maps relevant parameters.
/// </summary>
public static void DefineStubGenericParameters(MethodBuilder/*!*/ stub, Type[]/*!!*/ genericParameters,
PhpRoutineSignature/*!*/ targetSignature, Type[]/*!!*/ parameters)
{
// determine generic parameter names
string[] generic_param_names = new string[genericParameters.Length];
for (int j = 0; j < generic_param_names.Length; j++)
{
if (j < targetSignature.GenericParamCount)
{
generic_param_names[j] = targetSignature.GenericParams[j].Name.ToString();
}
else generic_param_names[j] = genericParameters[j].Name;
}
GenericTypeParameterBuilder[] generic_params = stub.DefineGenericParameters(generic_param_names);
// determine generic parameter attributes and constraints
for (int j = 0; j < generic_params.Length; j++)
{
Type template_type = genericParameters[j];
// attributes
generic_params[j].SetGenericParameterAttributes(template_type.GenericParameterAttributes);
// constraints
Type[] template_constraints = template_type.GetGenericParameterConstraints();
List<Type> interface_constraints = new List<Type>();
for (int k = 0; k < template_constraints.Length; k++)
{
if (template_constraints[k].IsClass) generic_params[j].SetBaseTypeConstraint(template_constraints[k]);
else interface_constraints.Add(template_constraints[k]);
}
generic_params[j].SetInterfaceConstraints(interface_constraints.ToArray());
}
// re-map base method generic parameters to the newly defined generic parameters
for (int j = 0; j < parameters.Length; j++)
{
if (parameters[j].IsGenericParameter && parameters[j].DeclaringMethod != null)
{
// method generic parameter
parameters[j] = generic_params[parameters[j].GenericParameterPosition];
}
}
}
private static void HandleGenericMethodArguments(MethodInfo targetMethod, MethodBuilder method)
{
if (targetMethod.ContainsGenericParameters)
{
var genericArguments = targetMethod.GetGenericArguments();
var genericParameters = method.DefineGenericParameters(
Array.ConvertAll<Type, string>(genericArguments,
new Converter<Type, string>(target => { return target.Name; })));
for (var i = 0; i < genericParameters.Length; i++)
{
var genericParameter = genericParameters[i];
var genericArgument = genericArguments[i];
genericParameter.SetGenericParameterAttributes(
genericArgument.GenericParameterAttributes);
var interfaceConstraints = new List<Type>();
Type baseTypeConstraint = null;
foreach (Type typeConstraint in genericArgument.GetGenericParameterConstraints())
{
if (typeConstraint.IsClass)
{
baseTypeConstraint = typeConstraint;
}
else
{
interfaceConstraints.Add(typeConstraint);
}
}
if (baseTypeConstraint != null)
{
genericParameter.SetBaseTypeConstraint(baseTypeConstraint);
}
if (interfaceConstraints.Count > 0)
{
genericParameter.SetInterfaceConstraints(interfaceConstraints.ToArray());
}
}
}
for (var i = 0; i < targetMethod.GetParameters().Length; i++)
{
var parameterInfo = targetMethod.GetParameters()[i];
method.DefineParameter(i + 1, parameterInfo.Attributes, parameterInfo.Name);
}
}
protected override void PreBuild()
{
if (Info != null)
{
return;
}
var cont = CurrentContainer;
Builder = cont.CreateMethod(Name, Attributes);
Info = Builder;
if (Generics.Count > 0)
{
var gb = Builder.DefineGenericParameters(Generics.ToNames());
Generics.RegisterBuilders(gb);
}
if (ReturnType != null)
{
Builder.SetReturnType(ReturnType.GainType()); //todo ジェネリクスに対応したTypeを生成する。
}
Builder.SetParameters(Arguments.ToTypes());
Arguments.RegisterBuilders(Builder, IsInstance);
SpreadGenerator();
}
protected ILGen DefineMethodOverride(MethodAttributes extra, MethodInfo decl, out MethodBuilder impl) {
MethodAttributes finalAttrs = (decl.Attributes & ~(MethodAttributesToEraseInOveride)) | extra;
if (!decl.DeclaringType.IsInterface) {
finalAttrs &= ~MethodAttributes.NewSlot;
}
if ((extra & MethodAttributes.MemberAccessMask) != 0) {
// remove existing member access, add new member access
finalAttrs &= ~MethodAttributes.MemberAccessMask;
finalAttrs |= extra;
}
Type[] signature = ReflectionUtils.GetParameterTypes(decl.GetParameters());
impl = _tg.DefineMethod(decl.Name, finalAttrs, decl.ReturnType, signature);
if (decl.IsGenericMethodDefinition) {
Type[] args = decl.GetGenericArguments();
string[] names = new string[args.Length];
for (int i = 0; i < args.Length; i++) {
names[i] = args[i].Name;
}
var builders = impl.DefineGenericParameters(names);
for (int i = 0; i < args.Length; i++) {
// Copy template parameter attributes
builders[i].SetGenericParameterAttributes(args[i].GenericParameterAttributes);
// Copy template parameter constraints
Type[] constraints = args[i].GetGenericParameterConstraints();
List<Type> interfaces = new List<Type>(constraints.Length);
foreach (Type constraint in constraints) {
if (constraint.IsInterface) {
interfaces.Add(constraint);
} else {
builders[i].SetBaseTypeConstraint(constraint);
}
}
if (interfaces.Count > 0) {
builders[i].SetInterfaceConstraints(interfaces.ToArray());
}
}
}
return CreateILGen(impl.GetILGenerator());
}
/// <summary>
/// Defines generic method parameters based on proxied method metadata.
/// </summary>
/// <param name="methodBuilder">
/// The <see cref="System.Reflection.Emit.MethodBuilder"/> to use.
/// </param>
/// <param name="method">The method to proxy.</param>
protected void DefineGenericParameters(MethodBuilder methodBuilder, MethodInfo method)
{
if (method.IsGenericMethodDefinition)
{
Type[] genericArguments = method.GetGenericArguments();
// define generic parameters
GenericTypeParameterBuilder[] gtpBuilders =
methodBuilder.DefineGenericParameters(ReflectionUtils.GetGenericParameterNames(genericArguments));
// define constraints for each generic parameter
for (int i = 0; i < genericArguments.Length; i++)
{
gtpBuilders[i].SetGenericParameterAttributes(genericArguments[i].GenericParameterAttributes);
Type[] constraints = genericArguments[i].GetGenericParameterConstraints();
System.Collections.Generic.List<Type> interfaces = new System.Collections.Generic.List<Type>(constraints.Length);
foreach (Type constraint in constraints)
{
if (constraint.IsClass)
gtpBuilders[i].SetBaseTypeConstraint(constraint);
else
interfaces.Add(constraint);
}
gtpBuilders[i].SetInterfaceConstraints(interfaces.ToArray());
}
}
}
public void Compile()
{
GreatestFixedPointFunction = module.DefineType(moduleName + '.' + Constants.TypesNamespace + '.' + name + Constants.FunctionSuffix,
TypeAttributes.Public | TypeAttributes.Interface | TypeAttributes.Abstract);
var functionClassGenericParameters = GreatestFixedPointFunction.DefineGenericParameters(new[] { Constants.GFixFunctionClassGenericParameterName }.Concat(declaration.TypeParameters).ToArray());
GreatestFixedPointFunctionApplyMethod = GreatestFixedPointFunction.DefineMethod(Constants.ApplyMethodName,
MethodAttributes.Public | MethodAttributes.Abstract | MethodAttributes.Virtual);
var underlyingType = GreatestFixedPointFunctionApplyMethod.DefineGenericParameters(Constants.ApplyMethodGenericParameterName)[0];
var functorClass = FunctorTypeMapper.Map(declaration.Type, declaration.VariableName, underlyingType,
functionClassGenericParameters.Skip(1).ToArray(), runtimeContainer);
GreatestFixedPointFunctionApplyMethod.SetParameters(underlyingType, typeof(IFunction<,>).MakeGenericType(underlyingType, functorClass));
GreatestFixedPointFunctionApplyMethod.SetReturnType(functionClassGenericParameters[0]);
TypeBuilder = module.DefineType(moduleName + '.' + Constants.TypesNamespace + '.' + name,
TypeAttributes.Public | TypeAttributes.Interface | TypeAttributes.Abstract);
var typeGenericParameters = declaration.TypeParameters.Any() ? TypeBuilder.DefineGenericParameters(declaration.TypeParameters) : TypeBuilder.EmptyTypes;
GreatestFixedPointApplyMethod = TypeBuilder.DefineMethod(Constants.ApplyMethodName,
MethodAttributes.Public | MethodAttributes.Abstract | MethodAttributes.Virtual);
var resultTypeGfix = GreatestFixedPointApplyMethod.DefineGenericParameters(Constants.GFixFunctionClassGenericParameterName)[0];
GreatestFixedPointApplyMethod.SetParameters(GreatestFixedPointFunction.MakeGenericType(new[] { resultTypeGfix }.Concat(typeGenericParameters).ToArray()));
GreatestFixedPointApplyMethod.SetReturnType(resultTypeGfix);
CompileAnaClass();
CompileAna();
CompileAnaFunction();
CompileAnaFunction1();
CompileIn();
CompileInFunction();
CompileOut();
CompileOutFunction();
TypeBuilder.SetCustomAttribute(new CustomAttributeBuilder(
typeof(InfiniteAttribute).GetConstructors()[0],
new object[]
{
declaration.ConstructorFunctionName,
declaration.DestructorFunctionName,
declaration.AnaFunctionName,
InFunction
}));
}
public void Compile()
{
TypeBuilder = module.DefineType(moduleName + '.' + Constants.TypesNamespace + '.' + name,
TypeAttributes.Public | TypeAttributes.Interface | TypeAttributes.Abstract);
var genericParameters = declaration.TypeParameters.Any() ? ((TypeBuilder)TypeBuilder).DefineGenericParameters(declaration.TypeParameters) : TypeBuilder.EmptyTypes;
Cata = ((TypeBuilder)TypeBuilder).DefineMethod(Constants.CataMethodName,
MethodAttributes.Public | MethodAttributes.Abstract | MethodAttributes.Virtual);
var cataReturnType = Cata.DefineGenericParameters(Constants.CataMethodGenericParameterName)[0];
var functorClass = FunctorTypeMapper.Map(declaration.Type, declaration.VariableName, cataReturnType, genericParameters, runtimeContainer);
Cata.SetParameters(typeof(IFunction<,>).MakeGenericType(functorClass, cataReturnType));
Cata.SetReturnType(cataReturnType);
CompileCataFunction();
CompileCataFunction1();
CompileOutClass();
CompileOut();
CompileOutFunction();
CompileIn();
CompileInFunction();
TypeBuilder.SetCustomAttribute(new CustomAttributeBuilder(typeof(FiniteAttribute).GetConstructors()[0],
new object[]
{
declaration.ConstructorFunctionName,
declaration.DestructorFunctionName,
declaration.CataFunctionName,
InFunction
}));
}
private void CompileOut()
{
Out = utilityClass.DefineMethod(Constants.OutMethodName, MethodAttributes.Public | MethodAttributes.Static);
var genericParameters = declaration.TypeParameters.Any() ? Out.DefineGenericParameters(declaration.TypeParameters) : TypeBuilder.EmptyTypes;
var returnType = declaration.TypeParameters.Any()
? TypeBuilder.MakeGenericType(genericParameters)
: TypeBuilder;
var fGreatestFixedPoint = FunctorTypeMapper.Map(declaration.Type, declaration.VariableName, returnType, genericParameters, runtimeContainer);
Out.SetParameters(fGreatestFixedPoint);
Out.SetReturnType(returnType);
Out.SetCustomAttribute(new CustomAttributeBuilder(typeof(ExtensionAttribute).GetConstructors()[0], new object[0]));
var outBody = Out.GetILGenerator();
outBody.Emit(OpCodes.Ldarg_0);
outBody.Emit(OpCodes.Newobj, declaration.TypeParameters.Any()
? TypeBuilder.GetConstructor(
InFunction.MakeGenericType(genericParameters),
InFunctionConstructor)
: InFunctionConstructor);
outBody.Emit(OpCodes.Call, fmap.MakeGenericMethod(new[] { returnType, fGreatestFixedPoint }.Concat(genericParameters).ToArray()));
outBody.Emit(OpCodes.Call, Ana.MakeGenericMethod(new[] { fGreatestFixedPoint }.Concat(genericParameters).ToArray()));
outBody.Emit(OpCodes.Ret);
}
private void CompileIn()
{
CompileInGeneratingFunction();
In = utilityClass.DefineMethod(Constants.InMethodName, MethodAttributes.Public | MethodAttributes.Static);
var genericParameters = declaration.TypeParameters.Any() ? In.DefineGenericParameters(declaration.TypeParameters) : TypeBuilder.EmptyTypes;
var resultType = declaration.TypeParameters.Any()
? TypeBuilder.MakeGenericType(genericParameters.ToArray())
: TypeBuilder;
In.SetReturnType(FunctorTypeMapper.Map(declaration.Type, declaration.VariableName, resultType, genericParameters, runtimeContainer));
In.SetParameters(resultType);
In.SetCustomAttribute(new CustomAttributeBuilder(typeof(ExtensionAttribute).GetConstructors()[0], new object[0]));
var fGreatestFixedPoint = FunctorTypeMapper.Map(declaration.Type, declaration.VariableName, resultType, genericParameters, runtimeContainer);
var applyMethodGenericClass = declaration.TypeParameters.Any()
? TypeBuilder.GetMethod(
TypeBuilder.MakeGenericType(genericParameters),
GreatestFixedPointApplyMethod)
: GreatestFixedPointApplyMethod;
var applyMethodGenericMethod = applyMethodGenericClass.MakeGenericMethod(fGreatestFixedPoint);
var inBody = In.GetILGenerator();
inBody.Emit(OpCodes.Ldarg_0);
inBody.Emit(OpCodes.Newobj, declaration.TypeParameters.Any()
? TypeBuilder.GetConstructor(
InClass.MakeGenericType(genericParameters),
InGeneratingFunctionConstructor)
: InGeneratingFunctionConstructor);
inBody.Emit(OpCodes.Callvirt, applyMethodGenericMethod);
inBody.Emit(OpCodes.Ret);
}
private void CompileAna()
{
Ana = utilityClass.DefineMethod(Constants.AnaMethodName, MethodAttributes.Public | MethodAttributes.Static);
var anaGenericParameters = Ana.DefineGenericParameters(new[] { Constants.AnaMethodGenericParameterName }.Concat(declaration.TypeParameters).ToArray());
Ana.SetReturnType(declaration.TypeParameters.Any()
? TypeBuilder.MakeGenericType(anaGenericParameters.Skip(1).ToArray())
: TypeBuilder);
var functorClass = FunctorTypeMapper.Map(declaration.Type, declaration.VariableName, anaGenericParameters[0], anaGenericParameters.Skip(1).ToArray(), runtimeContainer);
var generatorType = typeof(IFunction<,>).MakeGenericType(anaGenericParameters[0], functorClass);
Ana.SetParameters(anaGenericParameters[0], generatorType);
var anaBody = Ana.GetILGenerator();
anaBody.Emit(OpCodes.Ldarg_0);
anaBody.Emit(OpCodes.Ldarg_1);
anaBody.Emit(OpCodes.Newobj, TypeBuilder.GetConstructor(AnaClass.MakeGenericType(anaGenericParameters), AnaClassConstructor));
anaBody.Emit(OpCodes.Ret);
}
private static void CopyGenericMethodAttributes(MethodInfo from, MethodBuilder to) {
if (from.IsGenericMethodDefinition) {
Type[] args = from.GetGenericArguments();
string[] names = new string[args.Length];
for (int i = 0; i < args.Length; i++) {
names[i] = args[i].Name;
}
var builders = to.DefineGenericParameters(names);
for (int i = 0; i < args.Length; i++) {
// Copy template parameter attributes
builders[i].SetGenericParameterAttributes(args[i].GenericParameterAttributes);
// Copy template parameter constraints
Type[] constraints = args[i].GetGenericParameterConstraints();
List<Type> interfaces = new List<Type>(constraints.Length);
foreach (Type constraint in constraints) {
if (constraint.IsInterface) {
interfaces.Add(constraint);
} else {
builders[i].SetBaseTypeConstraint(constraint);
}
}
if (interfaces.Count > 0) {
builders[i].SetInterfaceConstraints(interfaces.ToArray());
}
}
}
}
private void CompileIn()
{
In = utilityClass.DefineMethod(Constants.InMethodName, MethodAttributes.Public | MethodAttributes.Static);
var genericParameters = declaration.TypeParameters.Any() ? In.DefineGenericParameters(declaration.TypeParameters) : TypeBuilder.EmptyTypes;
var inputParameter = declaration.TypeParameters.Any() ? TypeBuilder.MakeGenericType(genericParameters.ToArray()) : TypeBuilder;
In.SetReturnType(FunctorTypeMapper.Map(declaration.Type, declaration.VariableName, inputParameter, genericParameters, runtimeContainer));
In.SetParameters(inputParameter);
In.SetCustomAttribute(new CustomAttributeBuilder(typeof(ExtensionAttribute).GetConstructors()[0], new object[0]));
var inBody = In.GetILGenerator();
var fLeastFixedPoint = FunctorTypeMapper.Map(declaration.Type, declaration.VariableName, inputParameter, genericParameters, runtimeContainer);
inBody.Emit(OpCodes.Ldarg_0);
inBody.Emit(OpCodes.Newobj, declaration.TypeParameters.Any()
? TypeBuilder.GetConstructor(
OutFunction.MakeGenericType(genericParameters),
OutFunctionConstructor)
: OutFunctionConstructor);
inBody.Emit(OpCodes.Call, fmap.MakeGenericMethod(new Type[] { fLeastFixedPoint, inputParameter }.Concat(genericParameters).ToArray()));
inBody.Emit(OpCodes.Callvirt, declaration.TypeParameters.Any()
? TypeBuilder.GetMethod(inputParameter, Cata).MakeGenericMethod(fLeastFixedPoint)
: Cata.MakeGenericMethod(fLeastFixedPoint));
inBody.Emit(OpCodes.Ret);
}
/// <summary>
/// Initializes a new instance of the <see cref="MethodBuilderHelper"/> class
/// with the specified parameters.
/// </summary>
/// <param name="typeBuilder">Associated <see cref="TypeBuilderHelper"/>.</param>
/// <param name="methodBuilder">A <see cref="MethodBuilder"/></param>
/// <param name="genericArguments">Generic arguments of the method.</param>
/// <param name="returnType">The return type of the method.</param>
/// <param name="parameterTypes">The types of the parameters of the method.</param>
internal MethodBuilderHelper(
TypeBuilderHelper typeBuilder,
MethodBuilder methodBuilder,
Type[] genericArguments,
Type returnType,
Type[] parameterTypes
)
: base(typeBuilder)
{
if (methodBuilder == null) throw new ArgumentNullException("methodBuilder");
if (genericArguments == null) throw new ArgumentNullException("genericArguments");
_methodBuilder = methodBuilder;
var genArgNames = genericArguments.Select(t => t.Name).ToArray();
var genParams = methodBuilder.DefineGenericParameters(genArgNames);
// Copy parameter constraints.
//
List<Type> interfaceConstraints = null;
for (var i = 0; i < genParams.Length; i++)
{
genParams[i].SetGenericParameterAttributes(genericArguments[i].GenericParameterAttributes);
foreach (var constraint in genericArguments[i].GetGenericParameterConstraints())
{
if (constraint.IsClass)
genParams[i].SetBaseTypeConstraint(constraint);
else
{
if (interfaceConstraints == null)
interfaceConstraints = new List<Type>();
interfaceConstraints.Add(constraint);
}
}
if (interfaceConstraints != null && interfaceConstraints.Count != 0)
{
genParams[i].SetInterfaceConstraints(interfaceConstraints.ToArray());
interfaceConstraints.Clear();
}
}
// When a method contains a generic parameter we need to replace all
// generic types from methodInfoDeclaration with local ones.
//
for (var i = 0; i < parameterTypes.Length; i++)
parameterTypes[i] = TypeHelper.TranslateGenericParameters(parameterTypes[i], genParams);
methodBuilder.SetParameters(parameterTypes);
methodBuilder.SetReturnType(TypeHelper.TranslateGenericParameters(returnType, genParams));
// Once all generic stuff is done is it is safe to call SetCustomAttribute
//
methodBuilder.SetCustomAttribute(Type.Assembly.BLToolkitAttribute);
}
private static void CopyGenericMethodParameters(MethodInfo targetMethod,
MethodDefinition method,
Dictionary<Type, Type> genArgMapping,
Func<Type, Type> typeReplacer)
{
if (targetMethod.IsGenericMethodDefinition)
{
var targetGenArgs = targetMethod.GetGenericArguments();
var items =
method.DefineGenericParameters(targetGenArgs.Select(x => x.Name).ToArray()).Zip(targetGenArgs,
(paramBuilder,
target) =>
new
{
paramBuilder,
target
})
.ToList();
foreach (var arg in items)
{
arg.paramBuilder.SetGenericParameterAttributes(arg.target.GenericParameterAttributes);
genArgMapping[arg.target] = arg.paramBuilder;
}
foreach (var arg in items)
{
IEnumerable<Type> interfaceConstraints =
arg.target.GetGenericParameterConstraints().Select(typeReplacer).ToList();
if (arg.target.BaseType != null)
{
var baseTypeFixed = typeReplacer(arg.target.BaseType);
if (!baseTypeFixed.IsInterface)
arg.paramBuilder.SetBaseTypeConstraint(baseTypeFixed);
else
{
//arg.paramBuilder.SetBaseTypeConstraint(typeof(object));
interfaceConstraints = interfaceConstraints.Append(baseTypeFixed);
}
//if (arg.target.BaseType.IsGenericParameter)
//{
// interfaceConstraints = interfaceConstraints.Except(arg.target.BaseType.GetInterfaces());
//}
}
arg.paramBuilder.SetInterfaceConstraints(interfaceConstraints.ToArray());
}
}
}
