internal static MethodDefinition Clone(MethodDefinition meth, ImportContext context) { MethodDefinition nm = new MethodDefinition( meth.Name, RVA.Zero, meth.Attributes, meth.ImplAttributes, meth.HasThis, meth.ExplicitThis, meth.CallingConvention); MethodReference contextMethod = context.GenericContext.Method; context.GenericContext.Method = nm; GenericParameter.CloneInto(meth, nm, context); nm.ReturnType.ReturnType = context.Import(meth.ReturnType.ReturnType); if (meth.ReturnType.Parameter != null) { nm.ReturnType.Parameter = ParameterDefinition.Clone(meth.ReturnType.Parameter, context); nm.ReturnType.Parameter.Method = nm; } if (meth.PInvokeInfo != null) { nm.PInvokeInfo = meth.PInvokeInfo; // TODO: import module ? } if (meth.HasParameters) { foreach (ParameterDefinition param in meth.Parameters) { nm.Parameters.Add(ParameterDefinition.Clone(param, context)); } } if (meth.HasOverrides) { foreach (MethodReference ov in meth.Overrides) { nm.Overrides.Add(context.Import(ov)); } } if (meth.HasCustomAttributes) { foreach (CustomAttribute ca in meth.CustomAttributes) { nm.CustomAttributes.Add(CustomAttribute.Clone(ca, context)); } } if (meth.HasSecurityDeclarations) { foreach (SecurityDeclaration sec in meth.SecurityDeclarations) { nm.SecurityDeclarations.Add(SecurityDeclaration.Clone(sec)); } } if (meth.Body != null) { nm.Body = MethodBody.Clone(meth.Body, nm, context); } context.GenericContext.Method = contextMethod; return(nm); }
static TypeDefinition ImportTypeDefinition(TypeDefinition type, ImportContext context) { return(TypeDefinition.Clone(type, context)); }
static MethodDefinition ImportMethodDefinition(MethodDefinition meth, ImportContext context) { return(MethodDefinition.Clone(meth, context)); }
static FieldDefinition ImportFieldDefinition(FieldDefinition field, ImportContext context) { return(FieldDefinition.Clone(field, context)); }
internal static void CloneInto(IGenericParameterProvider old, IGenericParameterProvider np, ImportContext context) { foreach (GenericParameter gp in old.GenericParameters) { GenericParameter ngp = Clone(gp, context); np.GenericParameters.Add(ngp); CloneConstraints(gp, ngp, context); } }
TypeSpecification GetTypeSpec(TypeSpecification original, ImportContext context) { TypeSpecification typeSpec; TypeReference elementType = ImportTypeReference(original.ElementType, context); if (original is PointerType) { typeSpec = new PointerType(elementType); } else if (original is ArrayType) // deal with complex arrays { typeSpec = new ArrayType(elementType); } else if (original is ReferenceType) { typeSpec = new ReferenceType(elementType); } else if (original is GenericInstanceType) { GenericInstanceType git = original as GenericInstanceType; GenericInstanceType genElemType = new GenericInstanceType(elementType); context.GenericContext.CheckProvider(genElemType.GetOriginalType(), git.GenericArguments.Count); foreach (TypeReference arg in git.GenericArguments) { genElemType.GenericArguments.Add(ImportTypeReference(arg, context)); } typeSpec = genElemType; } else if (original is ModifierOptional) { TypeReference mt = (original as ModifierOptional).ModifierType; typeSpec = new ModifierOptional(elementType, ImportTypeReference(mt, context)); } else if (original is ModifierRequired) { TypeReference mt = (original as ModifierRequired).ModifierType; typeSpec = new ModifierRequired(elementType, ImportTypeReference(mt, context)); } else if (original is SentinelType) { typeSpec = new SentinelType(elementType); } else if (original is FunctionPointerType) { FunctionPointerType ori = original as FunctionPointerType; FunctionPointerType fnptr = new FunctionPointerType( ori.HasThis, ori.ExplicitThis, ori.CallingConvention, new MethodReturnType(ImportTypeReference(ori.ReturnType.ReturnType, context))); foreach (ParameterDefinition parameter in ori.Parameters) { fnptr.Parameters.Add(new ParameterDefinition(ImportTypeReference(parameter.ParameterType, context))); } typeSpec = fnptr; } else { throw new ReflectionException("Unknown element type: {0}", original.GetType().Name); } return(typeSpec); }