Merge pull request #642 from Ventero/CleanCopyLocal

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

diff --git a/mcs/mcs/constant.cs b/mcs/mcs/constant.cs
index 3cb4804f421c59a9e5c7e6fa62242d88622d0fb9..397d72c9a4ae7653be65733999a337aaf1567695 100644 (file)
--- a/mcs/mcs/constant.cs
+++ b/mcs/mcs/constant.cs
@@ -3,10 +3,11 @@
 //
 // Author:
 //   Miguel de Icaza (miguel@ximian.com)
-//   Marek Safar (marek.safar@seznam.cz)
+//   Marek Safar (marek.safar@gmail.com)
 //
 // Copyright 2001-2003 Ximian, Inc.
 // Copyright 2003-2008 Novell, Inc.
+// Copyright 2011-2013 Xamarin Inc
 //
 
 using System;
@@ -57,15 +58,15 @@ namespace Mono.CSharp {
                }
 #endif
 
-               public override void Error_ValueCannotBeConverted (ResolveContext ec, Location loc, TypeSpec target, bool expl)
+               public override void Error_ValueCannotBeConverted (ResolveContext ec, TypeSpec target, bool expl)
                {
                        if (!expl && IsLiteral && 
                                BuiltinTypeSpec.IsPrimitiveTypeOrDecimal (target) &&
                                BuiltinTypeSpec.IsPrimitiveTypeOrDecimal (type)) {
                                ec.Report.Error (31, loc, "Constant value `{0}' cannot be converted to a `{1}'",
-                                       GetValueAsLiteral (), TypeManager.CSharpName (target));
+                                       GetValueAsLiteral (), target.GetSignatureForError ());
                        } else {
-                               base.Error_ValueCannotBeConverted (ec, loc, target, expl);
+                               base.Error_ValueCannotBeConverted (ec, target, expl);
                        }
                }
 
@@ -73,7 +74,7 @@ namespace Mono.CSharp {
                {
                        Constant c = ConvertImplicitly (type);
                        if (c == null)
-                               Error_ValueCannotBeConverted (ec, loc, type, false);
+                               Error_ValueCannotBeConverted (ec, type, false);
 
                        return c;
                }
@@ -88,7 +89,7 @@ namespace Mono.CSharp {
                        if (this.type == type)
                                return this;
 
-                       if (Convert.ImplicitNumericConversion (this, type) == null) 
+                       if (!Convert.ImplicitNumericConversionExists (this.type, type)) 
                                return null;
 
                        bool fail;                      
@@ -99,20 +100,15 @@ namespace Mono.CSharp {
                                // reached, by calling Convert.ImplicitStandardConversionExists
                                //
                                throw new InternalErrorException ("Missing constant conversion between `{0}' and `{1}'",
-                                 TypeManager.CSharpName (Type), TypeManager.CSharpName (type));
+                                Type.GetSignatureForError (), type.GetSignatureForError ());
                        }
 
-                       return CreateConstant (type, constant_value, loc);
+                       return CreateConstantFromValue (type, constant_value, loc);
                }
 
                //
                //  Returns a constant instance based on Type
                //
-               public static Constant CreateConstant (TypeSpec t, object v, Location loc)
-               {
-                       return CreateConstantFromValue (t, v, loc);
-               }
-
                public static Constant CreateConstantFromValue (TypeSpec t, object v, Location loc)
                {
                        switch (t.BuiltinType) {
@@ -159,8 +155,11 @@ namespace Mono.CSharp {
                                        return new NullConstant (t, loc);
                        }
 
-                       throw new InternalErrorException ("Constant value `{0}' has unexpected underlying type `{1}'",
-                               v, TypeManager.CSharpName (t));
+#if STATIC
+                       throw new InternalErrorException ("Constant value `{0}' has unexpected underlying type `{1}'", v, t.GetSignatureForError ());
+#else
+                       return null;
+#endif
                }
 
                public override Expression CreateExpressionTree (ResolveContext ec)
@@ -247,35 +246,52 @@ namespace Mono.CSharp {
                        return this;
                }
 
-               /// <summary>
-               ///   Attempts to do a compile-time folding of a constant cast.
-               /// </summary>
-               public Constant TryReduce (ResolveContext ec, TypeSpec target_type, Location loc)
+               //
+               // Attempts to do a compile-time folding of a constant cast and handles
+               // error reporting for constant overlows only, on normal conversion
+               // errors returns null
+               // 
+               public Constant Reduce (ResolveContext ec, TypeSpec target_type)
                {
                        try {
-                               return TryReduce (ec, target_type);
-                       }
-                       catch (OverflowException) {
+                               return TryReduceConstant (ec, target_type);
+                       } catch (OverflowException) {
                                if (ec.ConstantCheckState && Type.BuiltinType != BuiltinTypeSpec.Type.Decimal) {
                                        ec.Report.Error (221, loc,
                                                "Constant value `{0}' cannot be converted to a `{1}' (use `unchecked' syntax to override)",
                                                GetValueAsLiteral (), target_type.GetSignatureForError ());
                                } else {
-                                       Error_ValueCannotBeConverted (ec, loc, target_type, false);
+                                       Error_ValueCannotBeConverted (ec, target_type, false);
                                }
 
                                return New.Constantify (target_type, loc);
                        }
                }
 
-               Constant TryReduce (ResolveContext ec, TypeSpec target_type)
+               public Constant TryReduce (ResolveContext rc, TypeSpec targetType)
                {
-                       if (Type == target_type)
+                       try {
+                               return TryReduceConstant (rc, targetType);
+                       } catch (OverflowException) {
+                               return null;
+                       }
+               }
+
+               Constant TryReduceConstant (ResolveContext ec, TypeSpec target_type)
+               {
+                       if (Type == target_type) {
+                               //
+                               // Reducing literal value produces a new constant. Syntactically 10 is not same as (int)10 
+                               //
+                               if (IsLiteral)
+                                       return CreateConstantFromValue (target_type, GetValue (), loc);
+
                                return this;
+                       }
 
                        Constant c;
                        if (target_type.IsEnum) {
-                               c = TryReduce (ec, EnumSpec.GetUnderlyingType (target_type));
+                               c = TryReduceConstant (ec, EnumSpec.GetUnderlyingType (target_type));
                                if (c == null)
                                        return null;
 
@@ -371,16 +387,16 @@ namespace Mono.CSharp {
                        eclass = ExprClass.Value;
                }
 
-               public override void Error_ValueCannotBeConverted (ResolveContext ec, Location loc, TypeSpec target, bool expl)
+               public override void Error_ValueCannotBeConverted (ResolveContext ec, TypeSpec target, bool expl)
                {
                        try {
                                ConvertExplicitly (true, target);
-                               base.Error_ValueCannotBeConverted (ec, loc, target, expl);
+                               base.Error_ValueCannotBeConverted (ec, target, expl);
                        }
                        catch
                        {
                                ec.Report.Error (31, loc, "Constant value `{0}' cannot be converted to a `{1}'",
-                                       GetValue ().ToString (), TypeManager.CSharpName (target));
+                                       GetValue ().ToString (), target.GetSignatureForError ());
                        }
                }