Fixes for Java compilations:

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

diff --git a/mcs/mcs/literal.cs b/mcs/mcs/literal.cs
index a5668dbeb5c2e38e2dda7e0135c3cff7bee99e0e..4e2ffed15a054a734874545041ca7b3c896dd0e1 100644 (file)
--- a/mcs/mcs/literal.cs
+++ b/mcs/mcs/literal.cs
@@ -3,6 +3,7 @@
 //
 // Author:
 //   Miguel de Icaza (miguel@ximian.com)
+//   Marek Safar (marek.safar@seznam.cz)
 //
 // (C) 2001 Ximian, Inc.
 //
@@ -22,50 +23,32 @@ using System;
 using System.Reflection;
 using System.Reflection.Emit;
 
-//
-// I put System.Null just so we do not have to special case it on 
-// TypeManager.CSharpName
-//
-namespace System {
-       //
-       // Represents the Null Type, just used as a placeholder for the type in NullLiteral
-       //
-       public class Null {
-       }
-}
-       
 namespace Mono.CSharp {
 
        //
-       // The NullType just exists to compare type equality, and for
-       // expressions that might have the `null type'
-       //
-       public class NullType {
-       }
-
-       //
-       // The null Literal constant
+       // The null literal
        //
        public class NullLiteral : Constant {
                public NullLiteral (Location loc):
                        base (loc)
                {
                        eclass = ExprClass.Value;
+                       type = typeof (NullLiteral);
                }
-               
+
                override public string AsString ()
                {
-                       return "null";
+                       return GetSignatureForError ();
                }
-
-               public override object GetValue ()
+               
+               public override Expression CreateExpressionTree (EmitContext ec)
                {
-                       return null;
-               }
+                       type = TypeManager.object_type;
+                       return base.CreateExpressionTree (ec);
+               }               
 
                public override Expression DoResolve (EmitContext ec)
                {
-                       type = TypeManager.null_type;
                        return this;
                }
 
@@ -74,50 +57,73 @@ namespace Mono.CSharp {
                        ec.ig.Emit (OpCodes.Ldnull);
                }
 
-               public override Constant Increment ()
+               public override string ExprClassName {
+                       get {
+                               return GetSignatureForError ();
+                       }
+               }
+
+               public override string GetSignatureForError ()
                {
-                       throw new NotSupportedException ();
+                       return "null";
                }
 
-               public override bool IsDefaultValue {
-                       get {
-                               return true;
+               public override void Error_ValueCannotBeConverted (EmitContext ec, Location loc, Type t, bool expl)
+               {
+                       if (TypeManager.IsGenericParameter (t)) {
+                               Report.Error(403, loc,
+                                       "Cannot convert null to the type parameter `{0}' because it could be a value " +
+                                       "type. Consider using `default ({0})' instead", t.Name);
+                       } else {
+                               Report.Error(37, loc, "Cannot convert null to `{0}' because it is a value type",
+                                       TypeManager.CSharpName(t));
                        }
                }
 
-               public override bool IsNegative {
-                       get {
-                               return false;
-                       }
+               public override Constant ConvertImplicitly (Type targetType)
+               {
+                       if (targetType.IsPointer)
+                               return new EmptyConstantCast (NullPointer.Null, targetType);
+
+                       if (TypeManager.IsReferenceType (targetType))
+                               return new EmptyConstantCast (this, targetType);
+
+                       return null;
                }
 
-               public override bool IsZeroInteger {
-                       get { return true; }
+               public override object GetValue ()
+               {
+                       return null;
                }
 
-               public override string GetSignatureForError()
+               public override Constant Increment ()
                {
-                       return "null";
+                       throw new NotSupportedException ();
                }
 
-               public override void Error_ValueCannotBeConverted (Location loc, Type t, bool expl)
+               public override bool IsDefaultValue 
                {
-                       Report.Error (37, loc, "Cannot convert null to `{0}' because it is a value type",
-                               TypeManager.CSharpName (t));
+                       get { return true; }
                }
 
-               public override Constant ToType (Type type, Location loc)
+               public override bool IsNegative 
                {
-                       if (!type.IsValueType && !TypeManager.IsEnumType (type))
-                               return this;
+                       get { return false; }
+               }
 
-                       return base.ToType (type, loc);
+               public override bool IsNull {
+                       get { return true; }
                }
 
-               public override Constant Reduce(bool inCheckedContext, Type target_type)
+               public override bool IsZeroInteger 
+               {
+                       get { return true; }
+               }
+
+               public override Constant ConvertExplicitly(bool inCheckedContext, Type target_type)
                {
                        if (!TypeManager.IsValueType (target_type))
-                               return new NullCast (this, target_type);
+                               return new EmptyConstantCast (this, target_type);
 
                        return null;
                }
@@ -127,12 +133,7 @@ namespace Mono.CSharp {
        // A null literal in a pointer context
        //
        public class NullPointer : NullLiteral {
-               public static readonly NullLiteral Null;
-
-               static NullPointer ()
-               {
-                       Null = new NullPointer ();
-               }
+               public static readonly NullLiteral Null = new NullPointer ();
 
                private NullPointer ():
                        base (Location.Null)
@@ -144,6 +145,7 @@ namespace Mono.CSharp {
                {
                        ILGenerator ig = ec.ig;
                                
+                       // TODO: why not use Ldnull instead ?
                        ig.Emit (OpCodes.Ldc_I4_0);
                        ig.Emit (OpCodes.Conv_U);
                }
@@ -183,6 +185,22 @@ namespace Mono.CSharp {
                        type = TypeManager.int32_type;
                        return this;
                }
+
+               public override Constant ConvertImplicitly (Type type)
+               {
+                       ///
+                       /// The 0 literal can be converted to an enum value,
+                       ///
+                       if (Value == 0 && TypeManager.IsEnumType (type)) {
+                               Constant c = ConvertImplicitly (TypeManager.GetEnumUnderlyingType (type));
+                               if (c == null)
+                                       return null;
+
+                               return new EnumConstant (c, type);
+                       }
+                       return base.ConvertImplicitly (type);
+               }
+
        }
 
        public class UIntLiteral : UIntConstant {
@@ -247,7 +265,7 @@ namespace Mono.CSharp {
                        return this;
                }
 
-               public override void Error_ValueCannotBeConverted (Location loc, Type target, bool expl)
+               public override void Error_ValueCannotBeConverted (EmitContext ec, Location loc, Type target, bool expl)
                {
                        if (target == TypeManager.float_type) {
                                Error_664 (loc, "float", "f");
@@ -259,7 +277,7 @@ namespace Mono.CSharp {
                                return;
                        }
 
-                       base.Error_ValueCannotBeConverted (loc, target, expl);
+                       base.Error_ValueCannotBeConverted (ec, loc, target, expl);
                }
 
                static void Error_664 (Location loc, string type, string suffix)