public static MethodReference MakeGeneric (this MethodReference self, params TypeReference [] arguments) { var reference = new MethodReference(self.Name, self.ReturnType) { DeclaringType = self.DeclaringType.MakeGenericType (arguments), HasThis = self.HasThis, ExplicitThis = self.ExplicitThis, CallingConvention = self.CallingConvention, }; foreach (var parameter in self.Parameters) reference.Parameters.Add (new ParameterDefinition (parameter.ParameterType)); foreach (var generic_parameter in self.GenericParameters) reference.GenericParameters.Add (new GenericParameter (generic_parameter.Name, reference)); return reference; }
public CustomAttribute (MethodReference constructor) { this.constructor = constructor; this.resolved = true; }
internal CustomAttribute (uint signature, MethodReference constructor) { this.signature = signature; this.constructor = constructor; this.resolved = false; }
internal MethodSpecification (MethodReference method) { if (method == null) throw new ArgumentNullException ("method"); this.method = method; this.token = new MetadataToken (TokenType.MethodSpec); }
static MethodDefinition GetMethodDefinition(MethodReference method) { return CecilExtensions.ResolveWithinSameModule(method); }
MethodSpecification ImportMethodSpecification (MethodReference method, IGenericContext context) { if (!method.IsGenericInstance) throw new NotSupportedException (); var instance = (GenericInstanceMethod) method; var element_method = ImportMethod (instance.ElementMethod, context); var imported_instance = new GenericInstanceMethod (element_method); var arguments = instance.GenericArguments; var imported_arguments = imported_instance.GenericArguments; for (int i = 0; i < arguments.Count; i++) imported_arguments.Add (ImportType (arguments [i], context)); return imported_instance; }
public MethodReference ImportMethod (SR.MethodBase method, IGenericContext context, ImportGenericKind import_kind) { if (IsMethodSpecification (method) || ImportOpenGenericMethod (method, import_kind)) return ImportMethodSpecification (method, context); var declaring_type = ImportType (method.DeclaringType, context); if (IsGenericInstance (method.DeclaringType)) method = method.Module.ResolveMethod (method.MetadataToken); var reference = new MethodReference { Name = method.Name, HasThis = HasCallingConvention (method, SR.CallingConventions.HasThis), ExplicitThis = HasCallingConvention (method, SR.CallingConventions.ExplicitThis), DeclaringType = ImportType (method.DeclaringType, context, ImportGenericKind.Definition), }; if (HasCallingConvention (method, SR.CallingConventions.VarArgs)) reference.CallingConvention &= MethodCallingConvention.VarArg; if (method.IsGenericMethod) ImportGenericParameters (reference, method.GetGenericArguments ()); var method_info = method as SR.MethodInfo; reference.ReturnType = method_info != null ? ImportType (method_info.ReturnType, context ?? reference) : ImportType (typeof (void), null); var parameters = method.GetParameters (); var reference_parameters = reference.Parameters; for (int i = 0; i < parameters.Length; i++) reference_parameters.Add ( new ParameterDefinition (ImportType (parameters [i].ParameterType, context ?? reference))); reference.DeclaringType = declaring_type; return reference; }
static MethodDefinition GetMethod (IAssemblyResolver resolver, TypeDefinition type, MethodReference reference) { while (type != null) { var method = GetMethod (type.Methods, reference); if (method != null) return method; if (type.BaseType == null) return null; type = Resolve (resolver, type.BaseType); } return null; }
public GenericInstanceMethod (MethodReference method) : base (method) { }
static MethodDefinition GetMethod(IAssemblyResolver resolver, TypeDefinition type, MethodReference reference) { while (type != null) { var method = GetMethod(type.Methods, reference); if (method != null) { return(method); } if (type.BaseType == null) { return(null); } type = Resolve(resolver, type.BaseType); } return(null); }
static void AdjustArgumentsForMethodCall(MethodReference cecilMethod, List<Expression> methodArgs) { // Convert 'ref' into 'out' where necessary for (int i = 0; i < methodArgs.Count && i < cecilMethod.Parameters.Count; i++) { DirectionExpression dir = methodArgs[i] as DirectionExpression; if (dir != null && cecilMethod.Parameters[i].IsOut) dir.FieldDirection = FieldDirection.Out; } }
static IEnumerable<AstType> ConvertTypeArguments(MethodReference cecilMethod) { GenericInstanceMethod g = cecilMethod as GenericInstanceMethod; if (g == null) return null; if (g.GenericArguments.Any(ta => ta.ContainsAnonymousType())) return null; return g.GenericArguments.Select(t => AstBuilder.ConvertType(t)); }
public static MethodDefinition GetMethod (IList<MethodDefinition> methods, MethodReference reference) { for (int i = 0; i < methods.Count; i++) { var method = methods [i]; if (method.Name != reference.Name) continue; if (method.HasGenericParameters != reference.HasGenericParameters) continue; if (method.HasGenericParameters && method.GenericParameters.Count != reference.GenericParameters.Count) continue; if (!AreSame (method.ReturnType, reference.ReturnType)) continue; if (method.HasParameters != reference.HasParameters) continue; if (!method.HasParameters && !reference.HasParameters) return method; if (!AreSame (method.Parameters, reference.Parameters)) continue; return method; } return null; }
public CustomAttribute (MethodReference constructor, byte [] blob) { this.constructor = constructor; this.resolved = false; this.blob = blob; }
public MethodReference ImportMethod (MethodReference method, IGenericContext context) { if (method.IsGenericInstance) return ImportMethodSpecification (method, context); var declaring_type = ImportType (method.DeclaringType, context); var reference = new MethodReference { Name = method.Name, HasThis = method.HasThis, ExplicitThis = method.ExplicitThis, DeclaringType = declaring_type, }; reference.CallingConvention = method.CallingConvention; if (method.HasGenericParameters) ImportGenericParameters (reference, method); reference.ReturnType = ImportType (method.ReturnType, context ?? reference); if (!method.HasParameters) return reference; var reference_parameters = reference.Parameters; var parameters = method.Parameters; for (int i = 0; i < parameters.Count; i++) reference_parameters.Add ( new ParameterDefinition (ImportType (parameters [i].ParameterType, context ?? reference))); return reference; }
public FunctionPointerType () : base (null) { this.function = new MethodReference (); this.function.Name = "method"; this.etype = MD.ElementType.FnPtr; }
public static MethodDefinition Resolve (IAssemblyResolver resolver, MethodReference method) { var type = Resolve (resolver, method.DeclaringType); if (type == null) return null; method = method.GetElementMethod (); if (!type.HasMethods) return null; return GetMethod (resolver, type, method); }