2 // delegate.cs: Delegate Handler
5 // Ravi Pratap (ravi@ximian.com)
6 // Miguel de Icaza (miguel@ximian.com)
7 // Marek Safar (marek.safar@gmail.com)
9 // Dual licensed under the terms of the MIT X11 or GNU GPL
11 // Copyright 2001 Ximian, Inc (http://www.ximian.com)
12 // Copyright 2003-2008 Novell, Inc (http://www.ximian.com)
16 using System
.Collections
;
17 using System
.Reflection
;
18 using System
.Reflection
.Emit
;
21 namespace Mono
.CSharp
{
26 public class Delegate
: DeclSpace
, IMemberContainer
28 FullNamedExpression ReturnType
;
29 public ParametersCompiled Parameters
;
31 public ConstructorBuilder ConstructorBuilder
;
32 public MethodBuilder InvokeBuilder
;
33 public MethodBuilder BeginInvokeBuilder
;
34 public MethodBuilder EndInvokeBuilder
;
38 static string[] attribute_targets
= new string [] { "type", "return" }
;
40 Expression instance_expr
;
41 MethodBase delegate_method
;
42 ReturnParameter return_attributes
;
44 MemberCache member_cache
;
46 const MethodAttributes mattr
= MethodAttributes
.Public
| MethodAttributes
.HideBySig
|
47 MethodAttributes
.Virtual
| MethodAttributes
.NewSlot
;
49 const int AllowedModifiers
=
57 public Delegate (NamespaceEntry ns
, DeclSpace parent
, FullNamedExpression type
,
58 int mod_flags
, MemberName name
, ParametersCompiled param_list
,
60 : base (ns
, parent
, name
, attrs
)
63 this.ReturnType
= type
;
64 ModFlags
= Modifiers
.Check (AllowedModifiers
, mod_flags
,
65 IsTopLevel
? Modifiers
.INTERNAL
:
66 Modifiers
.PRIVATE
, name
.Location
);
67 Parameters
= param_list
;
70 public override void ApplyAttributeBuilder (Attribute a
, CustomAttributeBuilder cb
, PredefinedAttributes pa
)
72 if (a
.Target
== AttributeTargets
.ReturnValue
) {
73 if (return_attributes
== null)
74 return_attributes
= new ReturnParameter (InvokeBuilder
, Location
);
76 return_attributes
.ApplyAttributeBuilder (a
, cb
, pa
);
80 base.ApplyAttributeBuilder (a
, cb
, pa
);
83 public override TypeBuilder
DefineType ()
85 if (TypeBuilder
!= null)
89 if (TypeManager
.NamespaceClash (Name
, Location
))
92 ModuleBuilder builder
= Module
.Builder
;
94 TypeBuilder
= builder
.DefineType (
95 Name
, TypeAttr
, TypeManager
.multicast_delegate_type
);
97 TypeBuilder builder
= Parent
.TypeBuilder
;
99 string name
= Name
.Substring (1 + Name
.LastIndexOf ('.'));
100 TypeBuilder
= builder
.DefineNestedType (
101 name
, TypeAttr
, TypeManager
.multicast_delegate_type
);
104 TypeManager
.AddUserType (this);
108 string[] param_names
= new string [TypeParameters
.Length
];
109 for (int i
= 0; i
< TypeParameters
.Length
; i
++)
110 param_names
[i
] = TypeParameters
[i
].Name
;
112 GenericTypeParameterBuilder
[] gen_params
;
113 gen_params
= TypeBuilder
.DefineGenericParameters (param_names
);
115 int offset
= CountTypeParameters
- CurrentTypeParameters
.Length
;
116 for (int i
= offset
; i
< gen_params
.Length
; i
++)
117 CurrentTypeParameters
[i
- offset
].Define (gen_params
[i
]);
119 foreach (TypeParameter type_param
in CurrentTypeParameters
) {
120 if (!type_param
.Resolve (this))
124 Expression current
= new SimpleName (
125 MemberName
.Basename
, TypeParameters
, Location
);
126 current
= current
.ResolveAsTypeTerminal (this, false);
130 CurrentType
= current
.Type
;
137 public override bool Define ()
140 foreach (TypeParameter type_param
in TypeParameters
) {
141 if (!type_param
.Resolve (this))
145 foreach (TypeParameter type_param
in TypeParameters
) {
146 if (!type_param
.DefineType (this))
151 member_cache
= new MemberCache (TypeManager
.multicast_delegate_type
, this);
153 // FIXME: POSSIBLY make this static, as it is always constant
155 Type
[] const_arg_types
= new Type
[2];
156 const_arg_types
[0] = TypeManager
.object_type
;
157 const_arg_types
[1] = TypeManager
.intptr_type
;
159 const MethodAttributes ctor_mattr
= MethodAttributes
.RTSpecialName
| MethodAttributes
.SpecialName
|
160 MethodAttributes
.HideBySig
| MethodAttributes
.Public
;
162 ConstructorBuilder
= TypeBuilder
.DefineConstructor (ctor_mattr
,
163 CallingConventions
.Standard
,
166 ConstructorBuilder
.DefineParameter (1, ParameterAttributes
.None
, "object");
167 ConstructorBuilder
.DefineParameter (2, ParameterAttributes
.None
, "method");
169 // HACK because System.Reflection.Emit is lame
171 IParameterData
[] fixed_pars
= new IParameterData
[] {
172 new ParameterData ("object", Parameter
.Modifier
.NONE
),
173 new ParameterData ("method", Parameter
.Modifier
.NONE
)
176 AParametersCollection const_parameters
= new ParametersImported (
178 new Type
[] { TypeManager.object_type, TypeManager.intptr_type }
);
180 TypeManager
.RegisterMethod (ConstructorBuilder
, const_parameters
);
181 member_cache
.AddMember (ConstructorBuilder
, this);
183 ConstructorBuilder
.SetImplementationFlags (MethodImplAttributes
.Runtime
);
186 // Here the various methods like Invoke, BeginInvoke etc are defined
188 // First, call the `out of band' special method for
189 // defining recursively any types we need:
191 if (!Parameters
.Resolve (this))
198 // Check accessibility
199 foreach (Type partype
in Parameters
.Types
){
200 if (!IsAccessibleAs (partype
)) {
201 Report
.SymbolRelatedToPreviousError (partype
);
202 Report
.Error (59, Location
,
203 "Inconsistent accessibility: parameter type `{0}' is less accessible than delegate `{1}'",
204 TypeManager
.CSharpName (partype
),
205 GetSignatureForError ());
210 ReturnType
= ReturnType
.ResolveAsTypeTerminal (this, false);
211 if (ReturnType
== null)
214 ret_type
= ReturnType
.Type
;
216 if (!IsAccessibleAs (ret_type
)) {
217 Report
.SymbolRelatedToPreviousError (ret_type
);
218 Report
.Error (58, Location
,
219 "Inconsistent accessibility: return type `" +
220 TypeManager
.CSharpName (ret_type
) + "' is less " +
221 "accessible than delegate `" + GetSignatureForError () + "'");
225 CheckProtectedModifier ();
227 if (RootContext
.StdLib
&& TypeManager
.IsSpecialType (ret_type
)) {
228 Method
.Error1599 (Location
, ret_type
);
232 TypeManager
.CheckTypeVariance (ret_type
, Variance
.Covariant
, this);
235 // We don't have to check any others because they are all
236 // guaranteed to be accessible - they are standard types.
239 CallingConventions cc
= Parameters
.CallingConvention
;
241 InvokeBuilder
= TypeBuilder
.DefineMethod ("Invoke",
245 Parameters
.GetEmitTypes ());
247 InvokeBuilder
.SetImplementationFlags (MethodImplAttributes
.Runtime
);
249 TypeManager
.RegisterMethod (InvokeBuilder
, Parameters
);
250 member_cache
.AddMember (InvokeBuilder
, this);
252 if (TypeManager
.iasyncresult_type
!= null && TypeManager
.asynccallback_type
!= null) {
253 DefineAsyncMethods (cc
);
259 void DefineAsyncMethods (CallingConventions cc
)
264 ParametersCompiled async_parameters
= ParametersCompiled
.MergeGenerated (Parameters
, false,
266 new Parameter (null, "callback", Parameter
.Modifier
.NONE
, null, Location
),
267 new Parameter (null, "object", Parameter
.Modifier
.NONE
, null, Location
)
270 TypeManager
.asynccallback_type
,
271 TypeManager
.object_type
275 BeginInvokeBuilder
= TypeBuilder
.DefineMethod ("BeginInvoke",
276 mattr
, cc
, TypeManager
.iasyncresult_type
, async_parameters
.GetEmitTypes ());
278 BeginInvokeBuilder
.SetImplementationFlags (MethodImplAttributes
.Runtime
);
279 TypeManager
.RegisterMethod (BeginInvokeBuilder
, async_parameters
);
280 member_cache
.AddMember (BeginInvokeBuilder
, this);
283 // EndInvoke is a bit more interesting, all the parameters labeled as
284 // out or ref have to be duplicated here.
288 // Define parameters, and count out/ref parameters
290 ParametersCompiled end_parameters
;
293 foreach (Parameter p
in Parameters
.FixedParameters
) {
294 if ((p
.ModFlags
& Parameter
.Modifier
.ISBYREF
) != 0)
298 if (out_params
> 0) {
299 Type
[] end_param_types
= new Type
[out_params
];
300 Parameter
[] end_params
= new Parameter
[out_params
];
303 for (int i
= 0; i
< Parameters
.FixedParameters
.Length
; ++i
) {
304 Parameter p
= Parameters
[i
];
305 if ((p
.ModFlags
& Parameter
.Modifier
.ISBYREF
) == 0)
308 end_param_types
[param
] = Parameters
.Types
[i
];
309 end_params
[param
] = p
;
312 end_parameters
= ParametersCompiled
.CreateFullyResolved (end_params
, end_param_types
);
314 end_parameters
= ParametersCompiled
.EmptyReadOnlyParameters
;
317 end_parameters
= ParametersCompiled
.MergeGenerated (end_parameters
, false,
318 new Parameter (null, "result", Parameter
.Modifier
.NONE
, null, Location
), TypeManager
.iasyncresult_type
);
321 // Create method, define parameters, register parameters with type system
323 EndInvokeBuilder
= TypeBuilder
.DefineMethod ("EndInvoke", mattr
, cc
, ret_type
, end_parameters
.GetEmitTypes ());
324 EndInvokeBuilder
.SetImplementationFlags (MethodImplAttributes
.Runtime
);
326 end_parameters
.ApplyAttributes (EndInvokeBuilder
);
327 TypeManager
.RegisterMethod (EndInvokeBuilder
, end_parameters
);
328 member_cache
.AddMember (EndInvokeBuilder
, this);
331 public override void Emit ()
333 Parameters
.ApplyAttributes (InvokeBuilder
);
335 if (BeginInvokeBuilder
!= null) {
336 ParametersCompiled p
= (ParametersCompiled
) TypeManager
.GetParameterData (BeginInvokeBuilder
);
337 p
.ApplyAttributes (BeginInvokeBuilder
);
340 if (OptAttributes
!= null) {
341 OptAttributes
.Emit ();
347 protected override TypeAttributes TypeAttr
{
349 return Modifiers
.TypeAttr (ModFlags
, IsTopLevel
) |
350 TypeAttributes
.Class
| TypeAttributes
.Sealed
|
355 public override string[] ValidAttributeTargets
{
357 return attribute_targets
;
362 protected override bool VerifyClsCompliance ()
364 if (!base.VerifyClsCompliance ()) {
368 Parameters
.VerifyClsCompliance ();
370 if (!AttributeTester
.IsClsCompliant (ReturnType
.Type
)) {
371 Report
.Warning (3002, 1, Location
, "Return type of `{0}' is not CLS-compliant",
372 GetSignatureForError ());
378 public static ConstructorInfo
GetConstructor (Type container_type
, Type delegate_type
)
380 Type dt
= delegate_type
;
381 Type
[] g_args
= null;
382 if (TypeManager
.IsGenericType (delegate_type
)) {
383 g_args
= TypeManager
.GetTypeArguments (delegate_type
);
384 delegate_type
= TypeManager
.DropGenericTypeArguments (delegate_type
);
387 Delegate d
= TypeManager
.LookupDelegate (delegate_type
);
391 return TypeBuilder
.GetConstructor (dt
, d
.ConstructorBuilder
);
393 return d
.ConstructorBuilder
;
396 Expression ml
= Expression
.MemberLookup (container_type
,
397 null, dt
, ConstructorInfo
.ConstructorName
, MemberTypes
.Constructor
,
398 BindingFlags
.Public
| BindingFlags
.Instance
| BindingFlags
.DeclaredOnly
, Location
.Null
);
400 MethodGroupExpr mg
= ml
as MethodGroupExpr
;
402 Report
.Error (-100, Location
.Null
, "Internal error: could not find delegate constructor!");
403 // FIXME: null will cause a crash later
407 return (ConstructorInfo
) mg
.Methods
[0];
411 // Returns the MethodBase for "Invoke" from a delegate type, this is used
412 // to extract the signature of a delegate.
414 public static MethodInfo
GetInvokeMethod (Type container_type
, Type delegate_type
)
416 Type dt
= delegate_type
;
418 Type
[] g_args
= null;
419 if (TypeManager
.IsGenericType (delegate_type
)) {
420 g_args
= TypeManager
.GetTypeArguments (delegate_type
);
421 delegate_type
= TypeManager
.DropGenericTypeArguments (delegate_type
);
424 Delegate d
= TypeManager
.LookupDelegate (delegate_type
);
428 if (g_args
!= null) {
429 invoke
= TypeBuilder
.GetMethod (dt
, d
.InvokeBuilder
);
431 ParametersCompiled p
= (ParametersCompiled
) d
.Parameters
.InflateTypes (g_args
, g_args
);
432 TypeManager
.RegisterMethod (invoke
, p
);
437 return d
.InvokeBuilder
;
440 Expression ml
= Expression
.MemberLookup (container_type
, null, dt
,
441 "Invoke", Location
.Null
);
443 MethodGroupExpr mg
= ml
as MethodGroupExpr
;
445 Report
.Error (-100, Location
.Null
, "Internal error: could not find Invoke method!");
446 // FIXME: null will cause a crash later
450 invoke
= (MethodInfo
) mg
.Methods
[0];
452 if (g_args
!= null) {
453 AParametersCollection p
= TypeManager
.GetParameterData (invoke
);
454 p
= p
.InflateTypes (g_args
, g_args
);
455 TypeManager
.RegisterMethod (invoke
, p
);
464 // 15.2 Delegate compatibility
466 public static bool IsTypeCovariant (Expression a
, Type b
)
469 // For each value parameter (a parameter with no ref or out modifier), an
470 // identity conversion or implicit reference conversion exists from the
471 // parameter type in D to the corresponding parameter type in M
476 if (RootContext
.Version
== LanguageVersion
.ISO_1
)
479 return Convert
.ImplicitReferenceConversionExists (a
, b
);
483 /// Verifies whether the method in question is compatible with the delegate
484 /// Returns the method itself if okay and null if not.
486 public static MethodBase
VerifyMethod (Type container_type
, Type delegate_type
,
487 MethodGroupExpr old_mg
, MethodBase mb
)
489 bool is_method_definition
= TypeManager
.IsGenericMethodDefinition (mb
);
491 MethodInfo invoke_mb
= GetInvokeMethod (container_type
, delegate_type
);
492 if (invoke_mb
== null)
495 if (is_method_definition
)
496 invoke_mb
= (MethodInfo
) TypeManager
.DropGenericMethodArguments (invoke_mb
);
498 AParametersCollection invoke_pd
= TypeManager
.GetParameterData (invoke_mb
);
501 if (!is_method_definition
&& old_mg
.type_arguments
== null &&
502 !TypeManager
.InferTypeArguments (invoke_pd
, ref mb
))
505 AParametersCollection pd
= TypeManager
.GetParameterData (mb
);
507 if (invoke_pd
.Count
!= pd
.Count
)
510 for (int i
= pd
.Count
; i
> 0; ) {
513 Type invoke_pd_type
= invoke_pd
.Types
[i
];
514 Type pd_type
= pd
.Types
[i
];
515 Parameter
.Modifier invoke_pd_type_mod
= invoke_pd
.FixedParameters
[i
].ModFlags
;
516 Parameter
.Modifier pd_type_mod
= pd
.FixedParameters
[i
].ModFlags
;
518 invoke_pd_type_mod
&= ~Parameter
.Modifier
.PARAMS
;
519 pd_type_mod
&= ~Parameter
.Modifier
.PARAMS
;
521 if (invoke_pd_type_mod
!= pd_type_mod
)
524 if (TypeManager
.IsEqual (invoke_pd_type
, pd_type
))
527 if (IsTypeCovariant (new EmptyExpression (invoke_pd_type
), pd_type
))
533 Type invoke_mb_retval
= ((MethodInfo
) invoke_mb
).ReturnType
;
534 Type mb_retval
= ((MethodInfo
) mb
).ReturnType
;
535 if (TypeManager
.TypeToCoreType (invoke_mb_retval
) == TypeManager
.TypeToCoreType (mb_retval
))
538 //if (!IsTypeCovariant (mb_retval, invoke_mb_retval))
541 if (RootContext
.Version
== LanguageVersion
.ISO_1
)
548 // Verifies whether the invocation arguments are compatible with the
549 // delegate's target method
551 public static bool VerifyApplicability (EmitContext ec
, Type delegate_type
, ref Arguments args
, Location loc
)
558 arg_count
= args
.Count
;
560 MethodBase mb
= GetInvokeMethod (ec
.ContainerType
, delegate_type
);
561 MethodGroupExpr me
= new MethodGroupExpr (new MemberInfo
[] { mb }
, delegate_type
, loc
);
563 AParametersCollection pd
= TypeManager
.GetParameterData (mb
);
565 int pd_count
= pd
.Count
;
567 bool params_method
= pd
.HasParams
;
568 bool is_params_applicable
= false;
569 bool is_applicable
= me
.IsApplicable (ec
, ref args
, arg_count
, ref mb
, ref is_params_applicable
) == 0;
571 arg_count
= args
.Count
;
573 if (!is_applicable
&& !params_method
&& arg_count
!= pd_count
) {
574 Report
.Error (1593, loc
, "Delegate `{0}' does not take `{1}' arguments",
575 TypeManager
.CSharpName (delegate_type
), arg_count
.ToString ());
579 return me
.VerifyArgumentsCompat (
580 ec
, ref args
, arg_count
, mb
,
581 is_params_applicable
|| (!is_applicable
&& params_method
),
585 public static string FullDelegateDesc (MethodBase invoke_method
)
587 return TypeManager
.GetFullNameSignature (invoke_method
).Replace (".Invoke", "");
590 public override MemberCache MemberCache
{
596 public Expression InstanceExpression
{
598 return instance_expr
;
601 instance_expr
= value;
605 public MethodBase TargetMethod
{
607 return delegate_method
;
610 delegate_method
= value;
614 public Type TargetReturnType
{
620 public override AttributeTargets AttributeTargets
{
622 return AttributeTargets
.Delegate
;
627 // Represents header string for documentation comment.
629 public override string DocCommentHeader
{
633 #region IMemberContainer Members
635 string IMemberContainer
.Name
637 get { throw new NotImplementedException (); }
640 Type IMemberContainer
.Type
642 get { throw new NotImplementedException (); }
645 MemberCache IMemberContainer
.BaseCache
647 get { throw new NotImplementedException (); }
650 bool IMemberContainer
.IsInterface
{
656 MemberList IMemberContainer
.GetMembers (MemberTypes mt
, BindingFlags bf
)
658 throw new NotImplementedException ();
665 // Base class for `NewDelegate' and `ImplicitDelegateCreation'
667 public abstract class DelegateCreation
: Expression
, MethodGroupExpr
.IErrorHandler
669 protected ConstructorInfo constructor_method
;
670 protected MethodInfo delegate_method
;
671 // We keep this to handle IsBase only
672 protected MethodGroupExpr method_group
;
673 protected Expression delegate_instance_expression
;
675 // TODO: Should either cache it or use interface to abstract it
676 public static Arguments
CreateDelegateMethodArguments (AParametersCollection pd
, Location loc
)
678 Arguments delegate_arguments
= new Arguments (pd
.Count
);
679 for (int i
= 0; i
< pd
.Count
; ++i
) {
680 Argument
.AType atype_modifier
;
681 Type atype
= pd
.Types
[i
];
682 switch (pd
.FixedParameters
[i
].ModFlags
) {
683 case Parameter
.Modifier
.REF
:
684 atype_modifier
= Argument
.AType
.Ref
;
685 //atype = atype.GetElementType ();
687 case Parameter
.Modifier
.OUT
:
688 atype_modifier
= Argument
.AType
.Out
;
689 //atype = atype.GetElementType ();
695 delegate_arguments
.Add (new Argument (new TypeExpression (atype
, loc
), atype_modifier
));
697 return delegate_arguments
;
700 public override Expression
CreateExpressionTree (EmitContext ec
)
702 MemberAccess ma
= new MemberAccess (new MemberAccess (new QualifiedAliasMember ("global", "System", loc
), "Delegate", loc
), "CreateDelegate", loc
);
704 Arguments args
= new Arguments (3);
705 args
.Add (new Argument (new TypeOf (new TypeExpression (type
, loc
), loc
)));
706 args
.Add (new Argument (new NullLiteral (loc
)));
707 args
.Add (new Argument (new TypeOfMethodInfo (delegate_method
, loc
)));
708 Expression e
= new Invocation (ma
, args
).Resolve (ec
);
712 e
= Convert
.ExplicitConversion (ec
, e
, type
, loc
);
716 return e
.CreateExpressionTree (ec
);
719 public override Expression
DoResolve (EmitContext ec
)
721 constructor_method
= Delegate
.GetConstructor (ec
.ContainerType
, type
);
723 MethodInfo invoke_method
= Delegate
.GetInvokeMethod (ec
.ContainerType
, type
);
724 method_group
.DelegateType
= type
;
725 method_group
.CustomErrorHandler
= this;
727 Arguments arguments
= CreateDelegateMethodArguments (TypeManager
.GetParameterData (invoke_method
), loc
);
728 method_group
= method_group
.OverloadResolve (ec
, ref arguments
, false, loc
);
729 if (method_group
== null)
732 delegate_method
= (MethodInfo
) method_group
;
734 if (TypeManager
.IsNullableType (delegate_method
.DeclaringType
)) {
735 Report
.Error (1728, loc
, "Cannot create delegate from method `{0}' because it is a member of System.Nullable<T> type",
736 TypeManager
.GetFullNameSignature (delegate_method
));
740 Invocation
.IsSpecialMethodInvocation (delegate_method
, loc
);
742 ExtensionMethodGroupExpr emg
= method_group
as ExtensionMethodGroupExpr
;
744 delegate_instance_expression
= emg
.ExtensionExpression
;
745 Type e_type
= delegate_instance_expression
.Type
;
746 if (TypeManager
.IsValueType (e_type
)) {
747 Report
.Error (1113, loc
, "Extension method `{0}' of value type `{1}' cannot be used to create delegates",
748 TypeManager
.CSharpSignature (delegate_method
), TypeManager
.CSharpName (e_type
));
752 Type rt
= TypeManager
.TypeToCoreType (delegate_method
.ReturnType
);
753 Expression ret_expr
= new TypeExpression (rt
, loc
);
754 if (!Delegate
.IsTypeCovariant (ret_expr
, (TypeManager
.TypeToCoreType (invoke_method
.ReturnType
)))) {
755 Error_ConversionFailed (ec
, delegate_method
, ret_expr
);
758 if (Invocation
.IsMethodExcluded (delegate_method
, loc
)) {
759 Report
.SymbolRelatedToPreviousError (delegate_method
);
760 MethodOrOperator m
= TypeManager
.GetMethod (delegate_method
) as MethodOrOperator
;
761 if (m
!= null && m
.IsPartialDefinition
) {
762 Report
.Error (762, loc
, "Cannot create delegate from partial method declaration `{0}'",
763 TypeManager
.CSharpSignature (delegate_method
));
765 Report
.Error (1618, loc
, "Cannot create delegate with `{0}' because it has a Conditional attribute",
766 TypeManager
.CSharpSignature (delegate_method
));
770 DoResolveInstanceExpression (ec
);
771 eclass
= ExprClass
.Value
;
775 void DoResolveInstanceExpression (EmitContext ec
)
778 // Argument is another delegate
780 if (delegate_instance_expression
!= null)
783 Expression instance
= method_group
.InstanceExpression
;
784 if (instance
!= null && instance
!= EmptyExpression
.Null
) {
785 delegate_instance_expression
= instance
;
786 Type instance_type
= delegate_instance_expression
.Type
;
787 if (TypeManager
.IsValueType (instance_type
) || TypeManager
.IsGenericParameter (instance_type
)) {
788 delegate_instance_expression
= new BoxedCast (
789 delegate_instance_expression
, TypeManager
.object_type
);
791 } else if (!delegate_method
.IsStatic
&& !ec
.IsStatic
) {
792 delegate_instance_expression
= ec
.GetThis (loc
);
796 public override void Emit (EmitContext ec
)
798 if (delegate_instance_expression
== null)
799 ec
.ig
.Emit (OpCodes
.Ldnull
);
801 delegate_instance_expression
.Emit (ec
);
803 if (!delegate_method
.DeclaringType
.IsSealed
&& delegate_method
.IsVirtual
&& !method_group
.IsBase
) {
804 ec
.ig
.Emit (OpCodes
.Dup
);
805 ec
.ig
.Emit (OpCodes
.Ldvirtftn
, delegate_method
);
807 ec
.ig
.Emit (OpCodes
.Ldftn
, delegate_method
);
810 ec
.ig
.Emit (OpCodes
.Newobj
, constructor_method
);
813 void Error_ConversionFailed (EmitContext ec
, MethodBase method
, Expression return_type
)
815 MethodInfo invoke_method
= Delegate
.GetInvokeMethod (ec
.ContainerType
, type
);
816 string member_name
= delegate_instance_expression
!= null ?
817 Delegate
.FullDelegateDesc (method
) :
818 TypeManager
.GetFullNameSignature (method
);
820 Report
.SymbolRelatedToPreviousError (type
);
821 Report
.SymbolRelatedToPreviousError (method
);
822 if (RootContext
.Version
== LanguageVersion
.ISO_1
) {
823 Report
.Error (410, loc
, "A method or delegate `{0} {1}' parameters and return type must be same as delegate `{2} {3}' parameters and return type",
824 TypeManager
.CSharpName (((MethodInfo
) method
).ReturnType
), member_name
,
825 TypeManager
.CSharpName (invoke_method
.ReturnType
), Delegate
.FullDelegateDesc (invoke_method
));
828 if (return_type
== null) {
829 Report
.Error (123, loc
, "A method or delegate `{0}' parameters do not match delegate `{1}' parameters",
830 member_name
, Delegate
.FullDelegateDesc (invoke_method
));
834 Report
.Error (407, loc
, "A method or delegate `{0} {1}' return type does not match delegate `{2} {3}' return type",
835 return_type
.GetSignatureForError (), member_name
,
836 TypeManager
.CSharpName (invoke_method
.ReturnType
), Delegate
.FullDelegateDesc (invoke_method
));
839 public static MethodBase
ImplicitStandardConversionExists (MethodGroupExpr mg
, Type target_type
)
841 if (target_type
== TypeManager
.delegate_type
|| target_type
== TypeManager
.multicast_delegate_type
)
844 foreach (MethodInfo mi
in mg
.Methods
){
845 MethodBase mb
= Delegate
.VerifyMethod (mg
.DeclaringType
, target_type
, mg
, mi
);
852 public override void MutateHoistedGenericType (AnonymousMethodStorey storey
)
854 if (delegate_instance_expression
!= null)
855 delegate_instance_expression
.MutateHoistedGenericType (storey
);
857 delegate_method
= storey
.MutateGenericMethod (delegate_method
);
858 constructor_method
= storey
.MutateConstructor (constructor_method
);
861 #region IErrorHandler Members
863 public bool NoExactMatch (EmitContext ec
, MethodBase method
)
865 if (TypeManager
.IsGenericMethod (method
))
868 Error_ConversionFailed (ec
, method
, null);
872 public bool AmbiguousCall (MethodBase ambiguous
)
881 // Created from the conversion code
883 public class ImplicitDelegateCreation
: DelegateCreation
885 ImplicitDelegateCreation (Type t
, MethodGroupExpr mg
, Location l
)
888 this.method_group
= mg
;
892 static public Expression
Create (EmitContext ec
, MethodGroupExpr mge
,
893 Type target_type
, Location loc
)
895 ImplicitDelegateCreation d
= new ImplicitDelegateCreation (target_type
, mge
, loc
);
896 return d
.DoResolve (ec
);
901 // A delegate-creation-expression, invoked from the `New' class
903 public class NewDelegate
: DelegateCreation
905 public Arguments Arguments
;
908 // This constructor is invoked from the `New' expression
910 public NewDelegate (Type type
, Arguments Arguments
, Location loc
)
913 this.Arguments
= Arguments
;
917 public override Expression
DoResolve (EmitContext ec
)
919 if (Arguments
== null || Arguments
.Count
!= 1) {
920 Error_InvalidDelegateArgument ();
924 Argument a
= Arguments
[0];
925 if (!a
.ResolveMethodGroup (ec
))
928 Expression e
= a
.Expr
;
930 AnonymousMethodExpression ame
= e
as AnonymousMethodExpression
;
931 if (ame
!= null && RootContext
.Version
!= LanguageVersion
.ISO_1
) {
932 e
= ame
.Compatible (ec
, type
);
936 return e
.Resolve (ec
);
939 method_group
= e
as MethodGroupExpr
;
940 if (method_group
== null) {
941 if (!TypeManager
.IsDelegateType (e
.Type
)) {
942 e
.Error_UnexpectedKind (ResolveFlags
.MethodGroup
| ResolveFlags
.Type
, loc
);
947 // An argument is not a method but another delegate
949 delegate_instance_expression
= e
;
950 method_group
= new MethodGroupExpr (new MemberInfo
[] {
951 Delegate
.GetInvokeMethod (ec
.ContainerType
, e
.Type
) }, e
.Type
, loc
);
954 return base.DoResolve (ec
);
957 void Error_InvalidDelegateArgument ()
959 Report
.Error (149, loc
, "Method name expected");
963 public class DelegateInvocation
: ExpressionStatement
{
965 readonly Expression InstanceExpr
;
969 public DelegateInvocation (Expression instance_expr
, Arguments args
, Location loc
)
971 this.InstanceExpr
= instance_expr
;
972 this.Arguments
= args
;
976 public override Expression
CreateExpressionTree (EmitContext ec
)
978 Arguments args
= Arguments
.CreateForExpressionTree (ec
, Arguments
,
979 InstanceExpr
.CreateExpressionTree (ec
));
981 return CreateExpressionFactoryCall ("Invoke", args
);
984 public override Expression
DoResolve (EmitContext ec
)
986 if (InstanceExpr
is EventExpr
) {
987 ((EventExpr
) InstanceExpr
).Error_CannotAssign ();
991 Type del_type
= InstanceExpr
.Type
;
992 if (del_type
== null)
995 if (Arguments
!= null){
996 Arguments
.Resolve (ec
);
999 if (!Delegate
.VerifyApplicability (ec
, del_type
, ref Arguments
, loc
))
1002 method
= Delegate
.GetInvokeMethod (ec
.ContainerType
, del_type
);
1003 type
= TypeManager
.TypeToCoreType (method
.ReturnType
);
1004 eclass
= ExprClass
.Value
;
1009 public override void Emit (EmitContext ec
)
1012 // Invocation on delegates call the virtual Invoke member
1013 // so we are always `instance' calls
1015 Invocation
.EmitCall (ec
, false, InstanceExpr
, method
, Arguments
, loc
);
1018 public override void EmitStatement (EmitContext ec
)
1022 // Pop the return value if there is one
1024 if (type
!= TypeManager
.void_type
)
1025 ec
.ig
.Emit (OpCodes
.Pop
);
1028 public override void MutateHoistedGenericType (AnonymousMethodStorey storey
)
1030 method
= storey
.MutateGenericMethod (method
);
1031 type
= storey
.MutateType (type
);
1033 if (Arguments
!= null)
1034 Arguments
.MutateHoistedGenericType (storey
);
1036 InstanceExpr
.MutateHoistedGenericType (storey
);