[mcs] Reduced statement expressions can still be used as statements. Fixes #33142

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

diff --git a/mcs/mcs/ecore.cs b/mcs/mcs/ecore.cs
index 68e0551bb04fa6d0d620e4421914eed02ffed2d2..ce055dcbc3139d9fc071da68dd444b936968d027 100644 (file)
--- a/mcs/mcs/ecore.cs
+++ b/mcs/mcs/ecore.cs
@@ -1338,8 +1338,14 @@ namespace Mono.CSharp {
                                return null;
 
                        ExpressionStatement es = e as ExpressionStatement;
-                       if (es == null || e is AnonymousMethodBody)
+                       if (es == null || e is AnonymousMethodBody) {
+                               var reduced = e as IReducedExpressionStatement;
+                               if (reduced != null) {
+                                       return EmptyExpressionStatement.Instance;
+                               }
+
                                Error_InvalidExpressionStatement (ec);
+                       }
 
                        //
                        // This is quite expensive warning, try to limit the damage
@@ -1406,6 +1412,10 @@ namespace Mono.CSharp {
                }
        }
 
+       interface IReducedExpressionStatement
+       {
+       }
+
        /// <summary>
        ///   This kind of cast is used to encapsulate the child
        ///   whose type is child.Type into an expression that is
@@ -2213,7 +2223,7 @@ namespace Mono.CSharp {
        //
        public class ReducedExpression : Expression
        {
-               public sealed class ReducedConstantExpression : EmptyConstantCast
+               public class ReducedConstantExpression : EmptyConstantCast
                {
                        readonly Expression orig_expr;
 
@@ -2263,6 +2273,14 @@ namespace Mono.CSharp {
                        }
                }
 
+               sealed class ReducedConstantStatement : ReducedConstantExpression, IReducedExpressionStatement
+               {
+                       public ReducedConstantStatement (Constant expr, Expression origExpr)
+                               : base (expr, origExpr)
+                       {
+                       }
+               }
+
                sealed class ReducedExpressionStatement : ExpressionStatement
                {
                        readonly Expression orig_expr;
@@ -2344,12 +2362,15 @@ namespace Mono.CSharp {
                //
                // Creates fully resolved expression switcher
                //
-               public static Constant Create (Constant expr, Expression original_expr)
+               public static Constant Create (Constant expr, Expression originalExpr)
                {
                        if (expr.eclass == ExprClass.Unresolved)
                                throw new ArgumentException ("Unresolved expression");
 
-                       return new ReducedConstantExpression (expr, original_expr);
+                       if (originalExpr is ExpressionStatement)
+                               return new ReducedConstantStatement (expr, originalExpr);
+
+                       return new ReducedConstantExpression (expr, originalExpr);
                }
 
                public static ExpressionStatement Create (ExpressionStatement s, Expression orig)