mcs/nullable.cs

   1 //
   2 // nullable.cs: Nullable types support
   3 //
   4 // Authors: Martin Baulig (martin@ximian.com)
   5 //          Miguel de Icaza (miguel@ximian.com)
   6 //          Marek Safar (marek.safar@gmail.com)
   7 //
   8 // Dual licensed under the terms of the MIT X11 or GNU GPL
   9 //
  10 // Copyright 2001, 2002, 2003 Ximian, Inc (http://www.ximian.com)
  11 // Copyright 2004-2008 Novell, Inc
  12 //
  13
  14 using System;
  15 using System.Reflection;
  16 using System.Reflection.Emit;
  17 using System.Collections;
  18
  19 namespace Mono.CSharp.Nullable
  20 {
  21         public class NullableType : TypeExpr
  22         {
  23                 TypeExpr underlying;
  24
  25                 public NullableType (TypeExpr underlying, Location l)
  26                 {
  27                         this.underlying = underlying;
  28                         loc = l;
  29
  30                         eclass = ExprClass.Type;
  31                 }
  32
  33                 public NullableType (Type type, Location loc)
  34                         : this (new TypeExpression (type, loc), loc)
  35                 { }
  36
  37                 protected override TypeExpr DoResolveAsTypeStep (IMemberContext ec)
  38                 {
  39                         if (TypeManager.generic_nullable_type == null) {
  40                                 TypeManager.generic_nullable_type = TypeManager.CoreLookupType (ec.Compiler,
  41                                         "System", "Nullable`1", Kind.Struct, true);
  42                         }
  43
  44                         TypeArguments args = new TypeArguments (underlying);
  45                         GenericTypeExpr ctype = new GenericTypeExpr (TypeManager.generic_nullable_type, args, loc);
  46                         return ctype.ResolveAsTypeTerminal (ec, false);
  47                 }
  48
  49                 public override TypeExpr ResolveAsTypeTerminal (IMemberContext ec, bool silent)
  50                 {
  51                         return ResolveAsBaseTerminal (ec, silent);
  52                 }
  53         }
  54
  55         public sealed class NullableInfo
  56         {
  57                 public readonly Type Type;
  58                 public readonly Type UnderlyingType;
  59                 public MethodInfo HasValue;
  60                 public MethodInfo Value;
  61                 public MethodInfo GetValueOrDefault;
  62                 public ConstructorInfo Constructor;
  63
  64                 public NullableInfo (Type type)
  65                 {
  66                         Type = type;
  67                         UnderlyingType = TypeManager.TypeToCoreType (TypeManager.GetTypeArguments (type) [0]);
  68
  69                         PropertyInfo has_value_pi = TypeManager.GetPredefinedProperty (type, "HasValue", Location.Null, Type.EmptyTypes);
  70                         PropertyInfo value_pi = TypeManager.GetPredefinedProperty (type, "Value", Location.Null, Type.EmptyTypes);
  71                         GetValueOrDefault = TypeManager.GetPredefinedMethod (type, "GetValueOrDefault", Location.Null, Type.EmptyTypes);
  72
  73                         HasValue = has_value_pi.GetGetMethod (false);
  74                         Value = value_pi.GetGetMethod (false);
  75
  76                         // When compiling corlib
  77                         if (TypeManager.IsBeingCompiled (type)) {
  78                                 TypeContainer tc = TypeManager.LookupGenericTypeContainer (type);
  79
  80                                 // TODO: check for correct overload
  81                                 Constructor c = ((Constructor) tc.InstanceConstructors [0]);
  82
  83                                 Constructor = TypeBuilder.GetConstructor (type, c.ConstructorBuilder);
  84                                 return;
  85                         }
  86
  87 #if MS_COMPATIBLE
  88                         if (TypeManager.IsBeingCompiled (UnderlyingType)) {
  89                                 ConstructorInfo cinfo = TypeManager.DropGenericTypeArguments (type).GetConstructors ()[0];
  90                                 Constructor = TypeBuilder.GetConstructor (type, cinfo);
  91                                 return;
  92                         }
  93 #endif
  94
  95                         Constructor = type.GetConstructor (new Type[] { UnderlyingType });
  96                 }
  97         }
  98
  99         public class Unwrap : Expression, IMemoryLocation, IAssignMethod
 100         {
 101                 Expression expr;
 102                 NullableInfo info;
 103
 104                 LocalTemporary temp;
 105                 readonly bool useDefaultValue;
 106
 107                 Unwrap (Expression expr, bool useDefaultValue)
 108                 {
 109                         this.expr = expr;
 110                         this.loc = expr.Location;
 111                         this.useDefaultValue = useDefaultValue;
 112
 113                         info = new NullableInfo (expr.Type);
 114                         type = info.UnderlyingType;
 115                         eclass = expr.eclass;
 116                 }
 117
 118                 public static Expression Create (Expression expr)
 119                 {
 120                         //
 121                         // Avoid unwraping and wraping of same type
 122                         //
 123                         Wrap wrap = expr as Wrap;
 124                         if (wrap != null)
 125                                 return wrap.Child;
 126
 127                         return Create (expr, false);
 128                 }
 129
 130                 public static Unwrap Create (Expression expr, bool useDefaultValue)
 131                 {
 132                         return new Unwrap (expr, useDefaultValue);
 133                 }
 134
 135                 public override Expression CreateExpressionTree (ResolveContext ec)
 136                 {
 137                         return expr.CreateExpressionTree (ec);
 138                 }
 139
 140                 protected override Expression DoResolve (ResolveContext ec)
 141                 {
 142                         return this;
 143                 }
 144
 145                 public override Expression DoResolveLValue (ResolveContext ec, Expression right_side)
 146                 {
 147                         return DoResolve (ec);
 148                 }
 149
 150                 public override void Emit (EmitContext ec)
 151                 {
 152                         Store (ec);
 153                         if (useDefaultValue)
 154                                 Invocation.EmitCall (ec, false, this, info.GetValueOrDefault, null, loc);
 155                         else
 156                                 Invocation.EmitCall (ec, false, this, info.Value, null, loc);
 157                 }
 158
 159                 public void EmitCheck (EmitContext ec)
 160                 {
 161                         Store (ec);
 162                         Invocation.EmitCall (ec, false, this, info.HasValue, null, loc);
 163                 }
 164
 165                 public override bool Equals (object obj)
 166                 {
 167                         Unwrap uw = obj as Unwrap;
 168                         return uw != null && expr.Equals (uw.expr);
 169                 }
 170
 171                 public Expression Original {
 172                         get {
 173                                 return expr;
 174                         }
 175                 }
 176
 177                 public override int GetHashCode ()
 178                 {
 179                         return expr.GetHashCode ();
 180                 }
 181
 182                 public override bool IsNull {
 183                         get {
 184                                 return expr.IsNull;
 185                         }
 186                 }
 187
 188                 void Store (EmitContext ec)
 189                 {
 190                         if (expr is VariableReference)
 191                                 return;
 192
 193                         if (temp != null)
 194                                 return;
 195
 196                         expr.Emit (ec);
 197                         LocalVariable.Store (ec);
 198                 }
 199
 200                 public void Load (EmitContext ec)
 201                 {
 202                         if (expr is VariableReference)
 203                                 expr.Emit (ec);
 204                         else
 205                                 LocalVariable.Emit (ec);
 206                 }
 207
 208 #if NET_4_0
 209                 public override System.Linq.Expressions.Expression MakeExpression (BuilderContext ctx)
 210                 {
 211                         return expr.MakeExpression (ctx);
 212                 }
 213 #endif
 214
 215                 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
 216                 {
 217                         type = storey.MutateType (type);
 218                         info.Constructor = storey.MutateConstructor (info.Constructor);
 219                         info.HasValue = storey.MutateGenericMethod (info.HasValue);
 220                         info.GetValueOrDefault = storey.MutateGenericMethod (info.GetValueOrDefault);
 221                         info.Value = storey.MutateGenericMethod (info.Value);
 222                 }
 223
 224                 public void AddressOf (EmitContext ec, AddressOp mode)
 225                 {
 226                         IMemoryLocation ml = expr as VariableReference;
 227                         if (ml != null)
 228                                 ml.AddressOf (ec, mode);
 229                         else
 230                                 LocalVariable.AddressOf (ec, mode);
 231                 }
 232
 233                 //
 234                 // Keeps result of non-variable expression
 235                 //
 236                 LocalTemporary LocalVariable {
 237                         get {
 238                                 if (temp == null)
 239                                         temp = new LocalTemporary (info.Type);
 240                                 return temp;
 241                         }
 242                 }
 243
 244                 public void Emit (EmitContext ec, bool leave_copy)
 245                 {
 246                         if (leave_copy)
 247                                 Load (ec);
 248
 249                         Emit (ec);
 250                 }
 251
 252                 public void EmitAssign (EmitContext ec, Expression source,
 253                                         bool leave_copy, bool prepare_for_load)
 254                 {
 255                         InternalWrap wrap = new InternalWrap (source, info, loc);
 256                         ((IAssignMethod) expr).EmitAssign (ec, wrap, leave_copy, false);
 257                 }
 258
 259                 protected class InternalWrap : Expression
 260                 {
 261                         public Expression expr;
 262                         public NullableInfo info;
 263
 264                         public InternalWrap (Expression expr, NullableInfo info, Location loc)
 265                         {
 266                                 this.expr = expr;
 267                                 this.info = info;
 268                                 this.loc = loc;
 269
 270                                 type = info.Type;
 271                                 eclass = ExprClass.Value;
 272                         }
 273
 274                         public override Expression CreateExpressionTree (ResolveContext ec)
 275                         {
 276                                 throw new NotSupportedException ("ET");
 277                         }
 278
 279                         protected override Expression DoResolve (ResolveContext ec)
 280                         {
 281                                 return this;
 282                         }
 283
 284                         public override void Emit (EmitContext ec)
 285                         {
 286                                 expr.Emit (ec);
 287                                 ec.ig.Emit (OpCodes.Newobj, info.Constructor);
 288                         }
 289                 }
 290         }
 291
 292         public class Wrap : TypeCast
 293         {
 294                 readonly NullableInfo info;
 295
 296                 protected Wrap (Expression expr, Type type)
 297                         : base (expr, type)
 298                 {
 299                         info = new NullableInfo (type);
 300                         eclass = ExprClass.Value;
 301                 }
 302
 303                 public Expression Child {
 304                         get { return child; }
 305                 }
 306
 307                 public override Expression CreateExpressionTree (ResolveContext ec)
 308                 {
 309                         TypeCast child_cast = child as TypeCast;
 310                         if (child_cast != null) {
 311                                 child.Type = type;
 312                                 return child_cast.CreateExpressionTree (ec);
 313                         }
 314
 315                         return base.CreateExpressionTree (ec);
 316                 }
 317
 318                 public static Expression Create (Expression expr, Type type)
 319                 {
 320                         //
 321                         // Avoid unwraping and wraping of the same type
 322                         //
 323                         Unwrap unwrap = expr as Unwrap;
 324                         if (unwrap != null && TypeManager.IsEqual (expr.Type, TypeManager.TypeToCoreType (TypeManager.GetTypeArguments (type) [0])))
 325                                 return unwrap.Original;
 326
 327                         return new Wrap (expr, type);
 328                 }
 329
 330                 public override void Emit (EmitContext ec)
 331                 {
 332                         child.Emit (ec);
 333                         ec.ig.Emit (OpCodes.Newobj, info.Constructor);
 334                 }
 335         }
 336
 337         //
 338         // Represents null literal lifted to nullable type
 339         //
 340         public class LiftedNull : NullConstant, IMemoryLocation
 341         {
 342                 private LiftedNull (Type nullable_type, Location loc)
 343                         : base (nullable_type, loc)
 344                 {
 345                         eclass = ExprClass.Value;
 346                 }
 347
 348                 public static Constant Create (Type nullable, Location loc)
 349                 {
 350                         return new LiftedNull (nullable, loc);
 351                 }
 352
 353                 public static Expression CreateFromExpression (ResolveContext ec, Expression e)
 354                 {
 355                         ec.Report.Warning (458, 2, e.Location, "The result of the expression is always `null' of type `{0}'",
 356                                 TypeManager.CSharpName (e.Type));
 357
 358                         return ReducedExpression.Create (Create (e.Type, e.Location), e);
 359                 }
 360
 361                 public override void Emit (EmitContext ec)
 362                 {
 363                         // TODO: generate less temporary variables
 364                         LocalTemporary value_target = new LocalTemporary (type);
 365
 366                         value_target.AddressOf (ec, AddressOp.Store);
 367                         ec.ig.Emit (OpCodes.Initobj, type);
 368                         value_target.Emit (ec);
 369                 }
 370
 371                 public void AddressOf (EmitContext ec, AddressOp Mode)
 372                 {
 373                         LocalTemporary value_target = new LocalTemporary (type);
 374
 375                         value_target.AddressOf (ec, AddressOp.Store);
 376                         ec.ig.Emit (OpCodes.Initobj, type);
 377                         ((IMemoryLocation) value_target).AddressOf (ec, Mode);
 378                 }
 379         }
 380
 381         //
 382         // Generic lifting expression, supports all S/S? -> T/T? cases
 383         //
 384         public class Lifted : Expression, IMemoryLocation
 385         {
 386                 Expression expr, null_value;
 387                 Unwrap unwrap;
 388
 389                 public Lifted (Expression expr, Unwrap unwrap, Type type)
 390                 {
 391                         this.expr = expr;
 392                         this.unwrap = unwrap;
 393                         this.loc = expr.Location;
 394                         this.type = type;
 395                 }
 396
 397                 public Lifted (Expression expr, Expression unwrap, Type type)
 398                         : this (expr, unwrap as Unwrap, type)
 399                 {
 400                 }
 401
 402                 public override Expression CreateExpressionTree (ResolveContext ec)
 403                 {
 404                         return expr.CreateExpressionTree (ec);
 405                 }
 406
 407                 protected override Expression DoResolve (ResolveContext ec)
 408                 {
 409                         //
 410                         // It's null when lifting non-nullable type
 411                         //
 412                         if (unwrap == null) {
 413                                 // S -> T? is wrap only
 414                                 if (TypeManager.IsNullableType (type))
 415                                         return Wrap.Create (expr, type);
 416
 417                                 // S -> T can be simplified
 418                                 return expr;
 419                         }
 420
 421                         // Wrap target for T?
 422                         if (TypeManager.IsNullableType (type)) {
 423                                 expr = Wrap.Create (expr, type);
 424                                 if (expr == null)
 425                                         return null;
 426
 427                                 null_value = LiftedNull.Create (type, loc);
 428                         } else {
 429                                 null_value = new NullConstant (type, loc);
 430                         }
 431
 432                         eclass = ExprClass.Value;
 433                         return this;
 434                 }
 435
 436                 public override void Emit (EmitContext ec)
 437                 {
 438                         ILGenerator ig = ec.ig;
 439                         Label is_null_label = ig.DefineLabel ();
 440                         Label end_label = ig.DefineLabel ();
 441
 442                         unwrap.EmitCheck (ec);
 443                         ig.Emit (OpCodes.Brfalse, is_null_label);
 444
 445                         expr.Emit (ec);
 446
 447                         ig.Emit (OpCodes.Br, end_label);
 448                         ig.MarkLabel (is_null_label);
 449
 450                         null_value.Emit (ec);
 451                         ig.MarkLabel (end_label);
 452                 }
 453
 454                 public void AddressOf (EmitContext ec, AddressOp mode)
 455                 {
 456                         unwrap.AddressOf (ec, mode);
 457                 }
 458         }
 459
 460         public class LiftedUnaryOperator : Unary, IMemoryLocation
 461         {
 462                 Unwrap unwrap;
 463                 Expression user_operator;
 464
 465                 public LiftedUnaryOperator (Unary.Operator op, Expression expr)
 466                         : base (op, expr)
 467                 {
 468                 }
 469
 470                 public void AddressOf (EmitContext ec, AddressOp mode)
 471                 {
 472                         unwrap.AddressOf (ec, mode);
 473                 }
 474
 475                 public override Expression CreateExpressionTree (ResolveContext ec)
 476                 {
 477                         if (user_operator != null)
 478                                 return user_operator.CreateExpressionTree (ec);
 479
 480                         if (Oper == Operator.UnaryPlus)
 481                                 return Expr.CreateExpressionTree (ec);
 482
 483                         return base.CreateExpressionTree (ec);
 484                 }
 485
 486                 protected override Expression DoResolve (ResolveContext ec)
 487                 {
 488                         unwrap = Unwrap.Create (Expr, false);
 489                         if (unwrap == null)
 490                                 return null;
 491
 492                         Expression res = base.ResolveOperator (ec, unwrap);
 493                         if (res != this) {
 494                                 if (user_operator == null)
 495                                         return res;
 496                         } else {
 497                                 res = Expr = LiftExpression (ec, Expr);
 498                         }
 499
 500                         if (res == null)
 501                                 return null;
 502
 503                         eclass = ExprClass.Value;
 504                         type = res.Type;
 505                         return this;
 506                 }
 507
 508                 public override void Emit (EmitContext ec)
 509                 {
 510                         ILGenerator ig = ec.ig;
 511                         Label is_null_label = ig.DefineLabel ();
 512                         Label end_label = ig.DefineLabel ();
 513
 514                         unwrap.EmitCheck (ec);
 515                         ig.Emit (OpCodes.Brfalse, is_null_label);
 516
 517                         NullableInfo ni = new NullableInfo (type);
 518
 519                         if (user_operator != null) {
 520                                 user_operator.Emit (ec);
 521                         } else {
 522                                 EmitOperator (ec, ni.UnderlyingType);
 523                         }
 524
 525                         ig.Emit (OpCodes.Newobj, ni.Constructor);
 526                         ig.Emit (OpCodes.Br_S, end_label);
 527
 528                         ig.MarkLabel (is_null_label);
 529                         LiftedNull.Create (type, loc).Emit (ec);
 530
 531                         ig.MarkLabel (end_label);
 532                 }
 533
 534                 Expression LiftExpression (ResolveContext ec, Expression expr)
 535                 {
 536                         TypeExpr lifted_type = new NullableType (expr.Type, expr.Location);
 537                         lifted_type = lifted_type.ResolveAsTypeTerminal (ec, false);
 538                         if (lifted_type == null)
 539                                 return null;
 540
 541                         expr.Type = lifted_type.Type;
 542                         return expr;
 543                 }
 544
 545                 protected override Expression ResolveEnumOperator (ResolveContext ec, Expression expr)
 546                 {
 547                         expr = base.ResolveEnumOperator (ec, expr);
 548                         if (expr == null)
 549                                 return null;
 550
 551                         Expr = LiftExpression (ec, Expr);
 552                         return LiftExpression (ec, expr);
 553                 }
 554
 555                 protected override Expression ResolveUserOperator (ResolveContext ec, Expression expr)
 556                 {
 557                         expr = base.ResolveUserOperator (ec, expr);
 558                         if (expr == null)
 559                                 return null;
 560
 561                         //
 562                         // When a user operator is of non-nullable type
 563                         //
 564                         if (Expr is Unwrap) {
 565                                 user_operator = LiftExpression (ec, expr);
 566                                 return user_operator;
 567                         }
 568
 569                         return expr;
 570                 }
 571         }
 572
 573         public class LiftedBinaryOperator : Binary
 574         {
 575                 Unwrap left_unwrap, right_unwrap;
 576                 bool left_null_lifted, right_null_lifted;
 577                 Expression left_orig, right_orig;
 578                 Expression user_operator;
 579                 ConstructorInfo wrap_ctor;
 580
 581                 public LiftedBinaryOperator (Binary.Operator op, Expression left, Expression right,
 582                                              Location loc)
 583                         : base (op, left, right)
 584                 {
 585                         this.loc = loc;
 586                 }
 587
 588                 public override Expression CreateExpressionTree (ResolveContext ec)
 589                 {
 590                         if (user_operator != null)
 591                                 return user_operator.CreateExpressionTree (ec);
 592
 593                         return base.CreateExpressionTree (ec);
 594                 }
 595
 596                 //
 597                 // CSC 2 has this behavior, it allows structs to be compared
 598                 // with the null literal *outside* of a generics context and
 599                 // inlines that as true or false.
 600                 //
 601                 Expression CreateNullConstant (ResolveContext ec, Expression expr)
 602                 {
 603                         // FIXME: Handle side effect constants
 604                         Constant c = new BoolConstant (Oper == Operator.Inequality, loc).Resolve (ec);
 605
 606                         if ((Oper & Operator.EqualityMask) != 0) {
 607                                 ec.Report.Warning (472, 2, loc, "The result of comparing value type `{0}' with null is `{1}'",
 608                                         TypeManager.CSharpName (expr.Type), c.AsString ());
 609                         } else {
 610                                 ec.Report.Warning (464, 2, loc, "The result of comparing type `{0}' with null is always `{1}'",
 611                                         TypeManager.CSharpName (expr.Type), c.AsString ());
 612                         }
 613
 614                         return ReducedExpression.Create (c, this);
 615                 }
 616
 617                 protected override Expression DoResolve (ResolveContext ec)
 618                 {
 619                         if ((Oper & Operator.LogicalMask) != 0) {
 620                                 Error_OperatorCannotBeApplied (ec, left, right);
 621                                 return null;
 622                         }
 623
 624                         bool use_default_call = (Oper & (Operator.BitwiseMask | Operator.EqualityMask)) != 0;
 625                         left_orig = left;
 626                         if (TypeManager.IsNullableType (left.Type)) {
 627                                 left = left_unwrap = Unwrap.Create (left, use_default_call);
 628                                 if (left == null)
 629                                         return null;
 630                         }
 631
 632                         right_orig = right;
 633                         if (TypeManager.IsNullableType (right.Type)) {
 634                                 right = right_unwrap = Unwrap.Create (right, use_default_call);
 635                                 if (right == null)
 636                                         return null;
 637                         }
 638
 639                         //
 640                         // Some details are in 6.4.2, 7.2.7
 641                         // Arguments can be lifted for equal operators when the return type is bool and both
 642                         // arguments are of same type
 643                         //
 644                         if (left_orig.IsNull) {
 645                                 left = right;
 646                                 left_null_lifted = true;
 647                                 type = TypeManager.bool_type;
 648                         }
 649
 650                         if (right_orig.IsNull) {
 651                                 right = left;
 652                                 right_null_lifted = true;
 653                                 type = TypeManager.bool_type;
 654                         }
 655
 656                         eclass = ExprClass.Value;
 657                         return DoResolveCore (ec, left_orig, right_orig);
 658                 }
 659
 660                 void EmitBitwiseBoolean (EmitContext ec)
 661                 {
 662                         ILGenerator ig = ec.ig;
 663
 664                         Label load_left = ig.DefineLabel ();
 665                         Label load_right = ig.DefineLabel ();
 666                         Label end_label = ig.DefineLabel ();
 667
 668                         left_unwrap.Emit (ec);
 669                         ig.Emit (OpCodes.Brtrue_S, load_right);
 670
 671                         right_unwrap.Emit (ec);
 672                         ig.Emit (OpCodes.Brtrue_S, load_left);
 673
 674                         left_unwrap.EmitCheck (ec);
 675                         ig.Emit (OpCodes.Brfalse_S, load_right);
 676
 677                         // load left
 678                         ig.MarkLabel (load_left);
 679
 680                         if (Oper == Operator.BitwiseAnd) {
 681                                 left_unwrap.Load (ec);
 682                         } else {
 683                                 right_unwrap.Load (ec);
 684                                 right_unwrap = left_unwrap;
 685                         }
 686                         ig.Emit (OpCodes.Br_S, end_label);
 687
 688                         // load right
 689                         ig.MarkLabel (load_right);
 690                         right_unwrap.Load (ec);
 691
 692                         ig.MarkLabel (end_label);
 693                 }
 694
 695                 //
 696                 // Emits optimized equality or inequality operator when possible
 697                 //
 698                 void EmitEquality (EmitContext ec)
 699                 {
 700                         ILGenerator ig = ec.ig;
 701
 702                         //
 703                         // Either left or right is null
 704                         //
 705                         if (left_unwrap != null && (right_null_lifted || right.IsNull)) {
 706                                 left_unwrap.EmitCheck (ec);
 707                                 if (Oper == Binary.Operator.Equality) {
 708                                         ig.Emit (OpCodes.Ldc_I4_0);
 709                                         ig.Emit (OpCodes.Ceq);
 710                                 }
 711                                 return;
 712                         }
 713
 714                         if (right_unwrap != null && (left_null_lifted || left.IsNull)) {
 715                                 right_unwrap.EmitCheck (ec);
 716                                 if (Oper == Binary.Operator.Equality) {
 717                                         ig.Emit (OpCodes.Ldc_I4_0);
 718                                         ig.Emit (OpCodes.Ceq);
 719                                 }
 720                                 return;
 721                         }
 722
 723                         Label dissimilar_label = ig.DefineLabel ();
 724                         Label end_label = ig.DefineLabel ();
 725
 726                         if (user_operator != null) {
 727                                 user_operator.Emit (ec);
 728                                 ig.Emit (Oper == Operator.Equality ? OpCodes.Brfalse_S : OpCodes.Brtrue_S, dissimilar_label);
 729                         } else {
 730                                 left.Emit (ec);
 731                                 right.Emit (ec);
 732
 733                                 ig.Emit (OpCodes.Bne_Un_S, dissimilar_label);
 734                         }
 735
 736                         if (left_unwrap != null)
 737                                 left_unwrap.EmitCheck (ec);
 738
 739                         if (right_unwrap != null)
 740                                 right_unwrap.EmitCheck (ec);
 741
 742                         if (left_unwrap != null && right_unwrap != null) {
 743                                 if (Oper == Operator.Inequality)
 744                                         ig.Emit (OpCodes.Xor);
 745                                 else
 746                                         ig.Emit (OpCodes.Ceq);
 747                         } else {
 748                                 if (Oper == Operator.Inequality) {
 749                                         ig.Emit (OpCodes.Ldc_I4_0);
 750                                         ig.Emit (OpCodes.Ceq);
 751                                 }
 752                         }
 753
 754                         ig.Emit (OpCodes.Br_S, end_label);
 755
 756                         ig.MarkLabel (dissimilar_label);
 757                         if (Oper == Operator.Inequality)
 758                                 ig.Emit (OpCodes.Ldc_I4_1);
 759                         else
 760                                 ig.Emit (OpCodes.Ldc_I4_0);
 761
 762                         ig.MarkLabel (end_label);
 763                 }
 764
 765                 public override void EmitBranchable (EmitContext ec, Label target, bool onTrue)
 766                 {
 767                         Emit (ec);
 768                         ec.ig.Emit (onTrue ? OpCodes.Brtrue : OpCodes.Brfalse, target);
 769                 }
 770
 771                 public override void Emit (EmitContext ec)
 772                 {
 773                         //
 774                         // Optimize same expression operation
 775                         //
 776                         if (right_unwrap != null && right.Equals (left))
 777                                 right_unwrap = left_unwrap;
 778
 779                         if (user_operator == null && IsBitwiseBoolean) {
 780                                 EmitBitwiseBoolean (ec);
 781                                 return;
 782                         }
 783
 784                         if ((Oper & Operator.EqualityMask) != 0) {
 785                                 EmitEquality (ec);
 786                                 return;
 787                         }
 788
 789                         ILGenerator ig = ec.ig;
 790
 791                         Label is_null_label = ig.DefineLabel ();
 792                         Label end_label = ig.DefineLabel ();
 793
 794                         if (left_unwrap != null) {
 795                                 left_unwrap.EmitCheck (ec);
 796                                 ig.Emit (OpCodes.Brfalse, is_null_label);
 797                         }
 798
 799                         //
 800                         // Don't emit HasValue check when left and right expressions are same
 801                         //
 802                         if (right_unwrap != null && !left.Equals (right)) {
 803                                 right_unwrap.EmitCheck (ec);
 804                                 ig.Emit (OpCodes.Brfalse, is_null_label);
 805                         }
 806
 807                         EmitOperator (ec, left.Type);
 808
 809                         if (wrap_ctor != null)
 810                                 ig.Emit (OpCodes.Newobj, wrap_ctor);
 811
 812                         ig.Emit (OpCodes.Br_S, end_label);
 813                         ig.MarkLabel (is_null_label);
 814
 815                         if ((Oper & Operator.ComparisonMask) != 0) {
 816                                 ig.Emit (OpCodes.Ldc_I4_0);
 817                         } else {
 818                                 LiftedNull.Create (type, loc).Emit (ec);
 819                         }
 820
 821                         ig.MarkLabel (end_label);
 822                 }
 823
 824                 protected override void EmitOperator (EmitContext ec, Type l)
 825                 {
 826                         if (user_operator != null) {
 827                                 user_operator.Emit (ec);
 828                                 return;
 829                         }
 830
 831                         if (TypeManager.IsNullableType (l))
 832                                 l = TypeManager.TypeToCoreType (TypeManager.GetTypeArguments (l) [0]);
 833
 834                         base.EmitOperator (ec, l);
 835                 }
 836
 837                 bool IsBitwiseBoolean {
 838                         get {
 839                                 return (Oper & Operator.BitwiseMask) != 0 && left_unwrap != null && right_unwrap != null &&
 840                                 left_unwrap.Type == TypeManager.bool_type && right_unwrap.Type == TypeManager.bool_type;
 841                         }
 842                 }
 843
 844                 Expression LiftResult (ResolveContext ec, Expression res_expr)
 845                 {
 846                         TypeExpr lifted_type;
 847
 848                         //
 849                         // Avoid double conversion
 850                         //
 851                         if (left_unwrap == null || left_null_lifted || !TypeManager.IsEqual (left_unwrap.Type, left.Type) || (left_unwrap != null && right_null_lifted)) {
 852                                 lifted_type = new NullableType (left.Type, loc);
 853                                 lifted_type = lifted_type.ResolveAsTypeTerminal (ec, false);
 854                                 if (lifted_type == null)
 855                                         return null;
 856
 857                                 if (left is UserCast || left is TypeCast)
 858                                         left.Type = lifted_type.Type;
 859                                 else
 860                                         left = EmptyCast.Create (left, lifted_type.Type);
 861                         }
 862
 863                         if (right_unwrap == null || right_null_lifted || !TypeManager.IsEqual (right_unwrap.Type, right.Type) || (right_unwrap != null && left_null_lifted)) {
 864                                 lifted_type = new NullableType (right.Type, loc);
 865                                 lifted_type = lifted_type.ResolveAsTypeTerminal (ec, false);
 866                                 if (lifted_type == null)
 867                                         return null;
 868
 869                                 if (right is UserCast || right is TypeCast)
 870                                         right.Type = lifted_type.Type;
 871                                 else
 872                                         right = EmptyCast.Create (right, lifted_type.Type);
 873                         }
 874
 875                         if ((Oper & Operator.ComparisonMask) == 0) {
 876                                 lifted_type = new NullableType (res_expr.Type, loc);
 877                                 lifted_type = lifted_type.ResolveAsTypeTerminal (ec, false);
 878                                 if (lifted_type == null)
 879                                         return null;
 880
 881                                 wrap_ctor = new NullableInfo (lifted_type.Type).Constructor;
 882                                 type = res_expr.Type = lifted_type.Type;
 883                         }
 884
 885                         if (left_null_lifted) {
 886                                 left = LiftedNull.Create (right.Type, left.Location);
 887
 888                                 if ((Oper & (Operator.ArithmeticMask | Operator.ShiftMask | Operator.BitwiseMask)) != 0)
 889                                         return LiftedNull.CreateFromExpression (ec, res_expr);
 890
 891                                 //
 892                                 // Value types and null comparison
 893                                 //
 894                                 if (right_unwrap == null || (Oper & Operator.RelationalMask) != 0)
 895                                         return CreateNullConstant (ec, right_orig).Resolve (ec);
 896                         }
 897
 898                         if (right_null_lifted) {
 899                                 right = LiftedNull.Create (left.Type, right.Location);
 900
 901                                 if ((Oper & (Operator.ArithmeticMask | Operator.ShiftMask | Operator.BitwiseMask)) != 0)
 902                                         return LiftedNull.CreateFromExpression (ec, res_expr);
 903
 904                                 //
 905                                 // Value types and null comparison
 906                                 //
 907                                 if (left_unwrap == null || (Oper & Operator.RelationalMask) != 0)
 908                                         return CreateNullConstant (ec, left_orig);
 909                         }
 910
 911                         return res_expr;
 912                 }
 913
 914                 protected override Expression ResolveOperatorPredefined (ResolveContext ec, Binary.PredefinedOperator [] operators, bool primitives_only, Type enum_type)
 915                 {
 916                         Expression e = base.ResolveOperatorPredefined (ec, operators, primitives_only, enum_type);
 917
 918                         if (e == this || enum_type != null)
 919                                 return LiftResult (ec, e);
 920
 921                         //
 922                         // 7.9.9 Equality operators and null
 923                         //
 924                         // The == and != operators permit one operand to be a value of a nullable type and
 925                         // the other to be the null literal, even if no predefined or user-defined operator
 926                         // (in unlifted or lifted form) exists for the operation.
 927                         //
 928                         if (e == null && (Oper & Operator.EqualityMask) != 0) {
 929                                 if ((left_null_lifted && right_unwrap != null) || (right_null_lifted && left_unwrap != null))
 930                                         return LiftResult (ec, this);
 931                         }
 932
 933                         return e;
 934                 }
 935
 936                 protected override Expression ResolveUserOperator (ResolveContext ec, Type l, Type r)
 937                 {
 938                         Expression expr = base.ResolveUserOperator (ec, l, r);
 939                         if (expr == null)
 940                                 return null;
 941
 942                         expr = LiftResult (ec, expr);
 943                         if (expr is Constant)
 944                                 return expr;
 945
 946                         type = expr.Type;
 947                         user_operator = expr;
 948                         return this;
 949                 }
 950         }
 951
 952         public class NullCoalescingOperator : Expression
 953         {
 954                 Expression left, right;
 955                 Unwrap unwrap;
 956
 957                 public NullCoalescingOperator (Expression left, Expression right, Location loc)
 958                 {
 959                         this.left = left;
 960                         this.right = right;
 961                         this.loc = loc;
 962                 }
 963
 964                 public override Expression CreateExpressionTree (ResolveContext ec)
 965                 {
 966                         if (left.Type == TypeManager.null_type)
 967                                 ec.Report.Error (845, loc, "An expression tree cannot contain a coalescing operator with null left side");
 968
 969                         UserCast uc = left as UserCast;
 970                         Expression conversion = null;
 971                         if (uc != null) {
 972                                 left = uc.Source;
 973
 974                                 Arguments c_args = new Arguments (2);
 975                                 c_args.Add (new Argument (uc.CreateExpressionTree (ec)));
 976                                 c_args.Add (new Argument (left.CreateExpressionTree (ec)));
 977                                 conversion = CreateExpressionFactoryCall (ec, "Lambda", c_args);
 978                         }
 979
 980                         Arguments args = new Arguments (3);
 981                         args.Add (new Argument (left.CreateExpressionTree (ec)));
 982                         args.Add (new Argument (right.CreateExpressionTree (ec)));
 983                         if (conversion != null)
 984                                 args.Add (new Argument (conversion));
 985
 986                         return CreateExpressionFactoryCall (ec, "Coalesce", args);
 987                 }
 988
 989                 Expression ConvertExpression (ResolveContext ec)
 990                 {
 991                         // TODO: ImplicitConversionExists should take care of this
 992                         if (left.eclass == ExprClass.MethodGroup)
 993                                 return null;
 994
 995                         Type ltype = left.Type;
 996
 997                         //
 998                         // If left is a nullable type and an implicit conversion exists from right to underlying type of left,
 999                         // the result is underlying type of left
1000                         //
1001                         if (TypeManager.IsNullableType (ltype)) {
1002                                 unwrap = Unwrap.Create (left, false);
1003                                 if (unwrap == null)
1004                                         return null;
1005
1006                                 if (Convert.ImplicitConversionExists (ec, right, unwrap.Type)) {
1007                                         left = unwrap;
1008                                         type = left.Type;
1009                                         right = Convert.ImplicitConversion (ec, right, type, loc);
1010                                         return this;
1011                                 }
1012                         } else if (TypeManager.IsReferenceType (ltype)) {
1013                                 if (Convert.ImplicitConversionExists (ec, right, ltype)) {
1014                                         //
1015                                         // Reduce (constant ?? expr) to constant
1016                                         //
1017                                         Constant lc = left as Constant;
1018                                         if (lc != null && !lc.IsDefaultValue)
1019                                                 return new SideEffectConstant (lc, right, loc).Resolve (ec);
1020
1021                                         //
1022                                         // Reduce (left ?? null) to left OR (null-constant ?? right) to right
1023                                         //
1024                                         if (right.IsNull || lc != null)
1025                                                 return ReducedExpression.Create (lc != null ? right : left, this);
1026
1027                                         right = Convert.ImplicitConversion (ec, right, ltype, loc);
1028                                         type = left.Type;
1029                                         return this;
1030                                 }
1031                         } else {
1032                                 return null;
1033                         }
1034
1035                         Type rtype = right.Type;
1036                         if (!Convert.ImplicitConversionExists (ec, unwrap != null ? unwrap : left, rtype) || right.eclass == ExprClass.MethodGroup)
1037                                 return null;
1038
1039                         //
1040                         // Reduce (null ?? right) to right
1041                         //
1042                         if (left.IsNull)
1043                                 return ReducedExpression.Create (right, this);
1044
1045                         left = Convert.ImplicitConversion (ec, unwrap != null ? unwrap : left, rtype, loc);
1046                         type = rtype;
1047                         return this;
1048                 }
1049
1050                 protected override Expression DoResolve (ResolveContext ec)
1051                 {
1052                         left = left.Resolve (ec);
1053                         right = right.Resolve (ec);
1054
1055                         if (left == null || right == null)
1056                                 return null;
1057
1058                         eclass = ExprClass.Value;
1059
1060                         Expression e = ConvertExpression (ec);
1061                         if (e == null) {
1062                                 Binary.Error_OperatorCannotBeApplied (ec, left, right, "??", loc);
1063                                 return null;
1064                         }
1065
1066                         return e;
1067                 }
1068
1069                 public override void Emit (EmitContext ec)
1070                 {
1071                         ILGenerator ig = ec.ig;
1072
1073                         Label end_label = ig.DefineLabel ();
1074
1075                         if (unwrap != null) {
1076                                 Label is_null_label = ig.DefineLabel ();
1077
1078                                 unwrap.EmitCheck (ec);
1079                                 ig.Emit (OpCodes.Brfalse, is_null_label);
1080
1081                                 left.Emit (ec);
1082                                 ig.Emit (OpCodes.Br, end_label);
1083
1084                                 ig.MarkLabel (is_null_label);
1085                                 right.Emit (ec);
1086
1087                                 ig.MarkLabel (end_label);
1088                                 return;
1089                         }
1090
1091                         left.Emit (ec);
1092
1093                         ig.Emit (OpCodes.Dup);
1094                         ig.Emit (OpCodes.Brtrue, end_label);
1095
1096                         ig.Emit (OpCodes.Pop);
1097                         right.Emit (ec);
1098
1099                         ig.MarkLabel (end_label);
1100                 }
1101
1102                 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
1103                 {
1104                         left.MutateHoistedGenericType (storey);
1105                         right.MutateHoistedGenericType (storey);
1106                         type = storey.MutateType (type);
1107                 }
1108
1109                 protected override void CloneTo (CloneContext clonectx, Expression t)
1110                 {
1111                         NullCoalescingOperator target = (NullCoalescingOperator) t;
1112
1113                         target.left = left.Clone (clonectx);
1114                         target.right = right.Clone (clonectx);
1115                 }
1116         }
1117
1118         public class LiftedUnaryMutator : ExpressionStatement
1119         {
1120                 public readonly UnaryMutator.Mode Mode;
1121                 Expression expr;
1122                 UnaryMutator underlying;
1123                 Unwrap unwrap;
1124
1125                 public LiftedUnaryMutator (UnaryMutator.Mode mode, Expression expr, Location loc)
1126                 {
1127                         this.expr = expr;
1128                         this.Mode = mode;
1129                         this.loc = loc;
1130                 }
1131
1132                 public override Expression CreateExpressionTree (ResolveContext ec)
1133                 {
1134                         return new SimpleAssign (this, this).CreateExpressionTree (ec);
1135                 }
1136
1137                 protected override Expression DoResolve (ResolveContext ec)
1138                 {
1139                         expr = expr.Resolve (ec);
1140                         if (expr == null)
1141                                 return null;
1142
1143                         unwrap = Unwrap.Create (expr, false);
1144                         if (unwrap == null)
1145                                 return null;
1146
1147                         underlying = (UnaryMutator) new UnaryMutator (Mode, unwrap).Resolve (ec);
1148                         if (underlying == null)
1149                                 return null;
1150
1151
1152                         eclass = ExprClass.Value;
1153                         type = expr.Type;
1154                         return this;
1155                 }
1156
1157                 void DoEmit (EmitContext ec, bool is_expr)
1158                 {
1159                         ILGenerator ig = ec.ig;
1160                         Label is_null_label = ig.DefineLabel ();
1161                         Label end_label = ig.DefineLabel ();
1162
1163                         unwrap.EmitCheck (ec);
1164                         ig.Emit (OpCodes.Brfalse, is_null_label);
1165
1166                         if (is_expr) {
1167                                 underlying.Emit (ec);
1168                                 ig.Emit (OpCodes.Br_S, end_label);
1169                         } else {
1170                                 underlying.EmitStatement (ec);
1171                         }
1172
1173                         ig.MarkLabel (is_null_label);
1174                         if (is_expr)
1175                                 LiftedNull.Create (type, loc).Emit (ec);
1176
1177                         ig.MarkLabel (end_label);
1178                 }
1179
1180                 public override void Emit (EmitContext ec)
1181                 {
1182                         DoEmit (ec, true);
1183                 }
1184
1185                 public override void EmitStatement (EmitContext ec)
1186                 {
1187                         DoEmit (ec, false);
1188                 }
1189         }
1190 }
1191