2008-03-14 Marek Safar <marek.safar@gmail.com>

	A fix for bug #370577
	* statement.cs, lambda.cs: Added extra limitations when dealing with void
	return type.

svn path=/trunk/mcs/; revision=98284

diff --git a/mcs/mcs/ChangeLog b/mcs/mcs/ChangeLog
index 33b27e9fd5e8fd0071a022772580d837845693be..b96148fbb2219ea530508b834aecb90b9ed88cf6 100644 (file)
--- a/mcs/mcs/ChangeLog
+++ b/mcs/mcs/ChangeLog
@@ -1,3 +1,9 @@
+2008-03-14  Marek Safar  <marek.safar@gmail.com>
+
+       A fix for bug #370577
+       * statement.cs, lambda.cs: Added extra limitations when dealing with void
+       return type.
+       
 2008-03-14  Marek Safar  <marek.safar@gmail.com>
 
        * typemanager.cs (CSharpName): Made 250 times faster.

diff --git a/mcs/mcs/lambda.cs b/mcs/mcs/lambda.cs
index f6b7e74c8b123eb3cce42cfd67634ad7414c9ba4..c500d323bdff91cb8e5900cccbc1f9e3254f0470 100644 (file)
--- a/mcs/mcs/lambda.cs
+++ b/mcs/mcs/lambda.cs
@@ -158,8 +158,6 @@ namespace Mono.CSharp {
        //
        public class ContextualReturn : Return
        {
-               bool statement_return;
-
                public ContextualReturn (Expression expr)
                        : base (expr, expr.Location)
                {
@@ -172,26 +170,27 @@ namespace Mono.CSharp {
 
                public override void Emit (EmitContext ec)
                {
-                       if (statement_return) {
-                               ExpressionStatement es = Expr as ExpressionStatement;
-                               if (es == null) {
-                                       Expr.Error_InvalidExpressionStatement ();
-                                       return;
-                               }
-                               
-                               es.EmitStatement (ec);
-                               return;
-                       }
-                       
-                       base.Emit (ec);
+                       if (ec.ReturnType == TypeManager.void_type)
+                               ((ExpressionStatement) Expr).EmitStatement (ec);
+                       else
+                               base.Emit (ec);
                }
 
                public override bool Resolve (EmitContext ec)
-               {               
+               {       
+                       //
+                       // When delegate returns void, only expression statements can be used
+                       //
                        if (ec.ReturnType == TypeManager.void_type) {
-                               statement_return = true;
                                Expr = Expr.Resolve (ec);
-                               return Expr != null;
+                               if (Expr == null)
+                                       return false;
+                               
+                               if (Expr is ExpressionStatement)
+                                       return true;
+                               
+                               Expr.Error_InvalidExpressionStatement ();
+                               return false;
                        }
 
                        return base.Resolve (ec);

diff --git a/mcs/mcs/statement.cs b/mcs/mcs/statement.cs
index d7f1fc42b9830c77a1da828a9f67195edfbd83dc..e193ecfc1e3ca1c0c7e4757f51f2574cb749e2a9 100644 (file)
--- a/mcs/mcs/statement.cs
+++ b/mcs/mcs/statement.cs
@@ -778,6 +778,12 @@ namespace Mono.CSharp {
 
                        if (Expr.Type != ec.ReturnType) {
                                if (ec.InferReturnType) {
+                                       //
+                                       // void cannot be used in contextual return
+                                       //
+                                       if (Expr.Type == TypeManager.void_type)
+                                               return false;
+
                                        ec.ReturnType = Expr.Type;
                                } else {
                                        Expr = Convert.ImplicitConversionRequired (