Merge branch 'master' into msbuilddll2

[mono.git] / mcs / mcs / delegate.cs

diff --git a/mcs/mcs/delegate.cs b/mcs/mcs/delegate.cs
index e5a317ffe49a01f80e4dc7cd538fcebba0037a34..21854b19ff051685338f18527b18627c8eef8c82 100644 (file)
--- a/mcs/mcs/delegate.cs
+++ b/mcs/mcs/delegate.cs
@@ -191,13 +191,13 @@ namespace Mono.CSharp {
                        // Don't emit async method for compiler generated delegates (e.g. dynamic site containers)
                        //
                        if (!IsCompilerGenerated) {
-                               DefineAsyncMethods (Parameters.CallingConvention, resolved_rt);
+                               DefineAsyncMethods (resolved_rt);
                        }
 
                        return true;
                }
 
-               void DefineAsyncMethods (CallingConventions cc, TypeExpression returnType)
+               void DefineAsyncMethods (TypeExpression returnType)
                {
                        var iasync_result = Module.PredefinedTypes.IAsyncResult;
                        var async_callback = Module.PredefinedTypes.AsyncCallback;
@@ -454,7 +454,7 @@ namespace Mono.CSharp {
                        Arguments delegate_arguments = new Arguments (pd.Count);
                        for (int i = 0; i < pd.Count; ++i) {
                                Argument.AType atype_modifier;
-                               switch (pd.FixedParameters [i].ModFlags) {
+                               switch (pd.FixedParameters [i].ModFlags & Parameter.Modifier.RefOutMask) {
                                case Parameter.Modifier.REF:
                                        atype_modifier = Argument.AType.Ref;
                                        break;
@@ -532,7 +532,7 @@ namespace Mono.CSharp {
                                }
                        }
 
-                       TypeSpec rt = delegate_method.ReturnType;
+                       TypeSpec rt = method_group.BestCandidateReturnType;
                        if (rt.BuiltinType == BuiltinTypeSpec.Type.Dynamic)
                                rt = ec.BuiltinTypes.Object;
 
@@ -541,7 +541,7 @@ namespace Mono.CSharp {
                                Error_ConversionFailed (ec, delegate_method, ret_expr);
                        }
 
-                       if (delegate_method.IsConditionallyExcluded (ec, loc)) {
+                       if (method_group.IsConditionallyExcluded) {
                                ec.Report.SymbolRelatedToPreviousError (delegate_method);
                                MethodOrOperator m = delegate_method.MemberDefinition as MethodOrOperator;
                                if (m != null && m.IsPartialDefinition) {
@@ -681,12 +681,31 @@ namespace Mono.CSharp {
 
                        return false;
                }
+               
+               bool HasMvar ()
+               {
+                       if (ContainsMethodTypeParameter (type))
+                               return false;
+
+                       var best = method_group.BestCandidate;
+                       if (ContainsMethodTypeParameter (best.DeclaringType))
+                               return false;
+
+                       if (best.TypeArguments != null) {
+                               foreach (var ta in best.TypeArguments) {
+                                       if (ContainsMethodTypeParameter (ta))
+                                               return false;
+                               }
+                       }
+
+                       return true;
+               }
 
                protected override Expression DoResolve (ResolveContext ec)
                {
                        var expr = base.DoResolve (ec);
                        if (expr == null)
-                               return null;
+                               return ErrorExpression.Instance;
 
                        if (ec.IsInProbingMode)
                                return expr;
@@ -700,10 +719,7 @@ namespace Mono.CSharp {
                        //
                        // Cannot easily cache types with MVAR
                        //
-                       if (ContainsMethodTypeParameter (type))
-                               return expr;
-
-                       if (ContainsMethodTypeParameter (method_group.BestCandidate.DeclaringType))
+                       if (!HasMvar ())
                                return expr;
 
                        //
@@ -828,6 +844,13 @@ namespace Mono.CSharp {
                        return CreateExpressionFactoryCall (ec, "Invoke", args);
                }
 
+               public override void FlowAnalysis (FlowAnalysisContext fc)
+               {
+                       InstanceExpr.FlowAnalysis (fc);
+                       if (arguments != null)
+                               arguments.FlowAnalysis (fc);
+               }
+
                protected override Expression DoResolve (ResolveContext ec)
                {               
                        TypeSpec del_type = InstanceExpr.Type;