2009-10-22 Marek Safar <marek.safar@gmail.com>

	* dynamic.cs, expression.cs: Pass logical binary flag to dynamic
	resolver.

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

diff --git a/mcs/mcs/ChangeLog b/mcs/mcs/ChangeLog
index 11f7da8f8438b900b8ef4791d6d449dfe762bd93..4ad5ef4419c7b3ea6f54c21bb69887146c4879b8 100644 (file)
--- a/mcs/mcs/ChangeLog
+++ b/mcs/mcs/ChangeLog
@@ -1,3 +1,8 @@
+2009-10-22  Marek Safar  <marek.safar@gmail.com>
+
+       * dynamic.cs, expression.cs: Pass logical binary flag to dynamic
+       resolver.
+
 2009-10-22  Marek Safar  <marek.safar@gmail.com>
 
        * dynamic.cs, ecore.cs: Dynamic invocation with void return type.

diff --git a/mcs/mcs/dynamic.cs b/mcs/mcs/dynamic.cs
index 338d7ec0c0df002fb001faf4dd10357b6fcbfc61..404cd1b14d3f73518d0664e741b075663e107e01 100644 (file)
--- a/mcs/mcs/dynamic.cs
+++ b/mcs/mcs/dynamic.cs
@@ -196,7 +196,7 @@ namespace Mono.CSharp
                Expression binder_expr;
 
                // Used by BinderFlags
-               CSharpBinderFlags flags;
+               protected CSharpBinderFlags flags;
 
                public DynamicExpressionStatement (IDynamicBinder binder, Arguments args, Location loc)
                {
@@ -279,20 +279,18 @@ namespace Mono.CSharp
 
                public override void Emit (EmitContext ec)
                {
-                       EmitCall (ec);
+                       EmitCall (ec,  false);
                }
 
                public override void EmitStatement (EmitContext ec)
                {
-                       flags = CSharpBinderFlags.ResultDiscarded;
-
-                       EmitCall (ec);
+                       EmitCall (ec, true);
                }
 
-               void EmitCall (EmitContext ec)
+               void EmitCall (EmitContext ec, bool isStatement)
                {
                        int dyn_args_count = arguments == null ? 0 : arguments.Count;
-                       TypeExpr site_type = CreateSiteType (RootContext.ToplevelTypes.Compiler, dyn_args_count);
+                       TypeExpr site_type = CreateSiteType (RootContext.ToplevelTypes.Compiler, dyn_args_count, isStatement);
                        FieldExpr site_field_expr = new FieldExpr (CreateSiteField (site_type).FieldBuilder, loc);
 
                        SymbolWriter.OpenCompilerGeneratedBlock (ec.ig);
@@ -339,9 +337,8 @@ namespace Mono.CSharp
                        return new MemberAccess (TypeManager.binder_type, name, loc);
                }
 
-               TypeExpr CreateSiteType (CompilerContext ctx, int dyn_args_count)
+               TypeExpr CreateSiteType (CompilerContext ctx, int dyn_args_count, bool is_statement)
                {
-                       bool is_statement = (flags & CSharpBinderFlags.ResultDiscarded) != 0;
                        int default_args = is_statement ? 1 : 2;
 
                        bool has_ref_out_argument = false;
@@ -451,13 +448,11 @@ namespace Mono.CSharp
 
        class DynamicConversion : DynamicExpressionStatement, IDynamicBinder
        {
-               CSharpBinderFlags flags;
-
                public DynamicConversion (Type targetType, CSharpBinderFlags flags, Arguments args, Location loc)
                        : base (null, args, loc)
                {
                        type = targetType;
-                       this.flags = flags;
+                       base.flags = flags;
                        base.binder = this;
                }
 
@@ -576,6 +571,12 @@ namespace Mono.CSharp
 
                        return new Invocation (GetBinder (is_member_access ? "InvokeMember" : "Invoke", loc), binder_args);
                }
+
+               public override void EmitStatement (EmitContext ec)
+               {
+                       flags = CSharpBinderFlags.ResultDiscarded;
+                       base.EmitStatement (ec);
+               }
        }
 
        class DynamicMemberBinder : DynamicExpressionStatement, IDynamicBinder, IAssignMethod

diff --git a/mcs/mcs/expression.cs b/mcs/mcs/expression.cs
index 0721b5078970a15b32b28d1e6d8962765b7b7e37..24afdeb9e0183678cfc1903495c2c77075cd8bea 100644 (file)
--- a/mcs/mcs/expression.cs
+++ b/mcs/mcs/expression.cs
@@ -3612,11 +3612,14 @@ namespace Mono.CSharp {
                        MemberAccess sle = new MemberAccess (new MemberAccess (
                                new QualifiedAliasMember (QualifiedAliasMember.GlobalAlias, "System", loc), "Linq", loc), "Expressions", loc);
 
-                       int flags = 0;
+                       CSharpBinderFlags flags = 0;
                        if (ec.HasSet (ResolveContext.Options.CheckedScope))
-                               flags = (int) CSharpBinderFlags.CheckedContext;
+                               flags = CSharpBinderFlags.CheckedContext;
 
-                       binder_args.Add (new Argument (new EnumConstant (new IntLiteral (flags, loc), TypeManager.binder_flags)));
+                       if ((oper & Operator.LogicalMask) != 0)
+                               flags |= CSharpBinderFlags.BinaryOperationLogical;
+
+                       binder_args.Add (new Argument (new EnumConstant (new IntLiteral ((int) flags, loc), TypeManager.binder_flags)));
                        binder_args.Add (new Argument (new MemberAccess (new MemberAccess (sle, "ExpressionType", loc), GetOperatorExpressionTypeName (), loc)));
                        binder_args.Add (new Argument (new ImplicitlyTypedArrayCreation ("[]", args.CreateDynamicBinderArguments (), loc)));
 
@@ -4045,27 +4048,19 @@ namespace Mono.CSharp {
        // A boolean-expression is an expression that yields a result
        // of type bool
        //
-       public class BooleanExpression : Expression
+       public class BooleanExpression : ShimExpression
        {
-               Expression expr;
-
                public BooleanExpression (Expression expr)
+                       : base (expr)
                {
-                       this.expr = expr;
                        this.loc = expr.Location;
                }
 
-               protected override void CloneTo (CloneContext clonectx, Expression t)
-               {
-                       BooleanExpression target = (BooleanExpression) t;
-                       target.expr = expr.Clone (clonectx);
-               }
-
                public override Expression CreateExpressionTree (ResolveContext ec)
                {
                        // TODO: We should emit IsTrue (v4) instead of direct user operator
                        // call but that would break csc compatibility
-                       throw new NotSupportedException ();
+                       return base.CreateExpressionTree (ec);
                }
 
                public override Expression DoResolve (ResolveContext ec)
@@ -4080,7 +4075,7 @@ namespace Mono.CSharp {
 
                        Assign ass = expr as Assign;
                        if (ass != null && ass.Source is Constant) {
-                               ec.Report.Warning (665, 3, expr.Location,
+                               ec.Report.Warning (665, 3, loc,
                                        "Assignment in conditional expression is always constant. Did you mean to use `==' instead ?");
                        }
 
@@ -4109,11 +4104,6 @@ namespace Mono.CSharp {
 
                        return converted;
                }
-
-               public override void Emit (EmitContext ec)
-               {
-                       throw new InternalErrorException ("Should not be reached");
-               }
        }
        
        /// <summary>