Fix floating number issue (Azure#49094)

* fix the issue and introduce test cases

* update

* resolve comments

* update to avoid the string parsing

* add long cases

Author: ArcturusZhang

sdk/provisioning/Azure.Provisioning/src/Expressions/BicepTypeMapping.cs

@@ -60,6 +60,8 @@ public static string ToLiteralString(object value, string? format) =>
             bool b => b.ToString(),
             int i => i.ToString(),
             long i => i.ToString(),
+            float f => f.ToString(),
+            double d => d.ToString(),
             string s => s,
             Uri u => u.AbsoluteUri,
             DateTimeOffset d => d.ToString("o"),
@@ -92,10 +94,12 @@ public static BicepExpression ToBicep(object? value, string? format)
             null => BicepSyntax.Null(),
             bool b => BicepSyntax.Value(b),
             int i => BicepSyntax.Value(i),
-            // Note: below cast is valid because bicep limits to int.Min/MaxValue
-            // in bicep source and you need to use a parameter file for larger
-            // values
-            long i => BicepSyntax.Value((int)i),
+            long l => FromLong(l),
+            // Note: bicep does not offically support floating numbers
+            // therefore for floating numbers we are taking a workaround from
+            // https://github.com/Azure/bicep/issues/1386#issuecomment-818077233
+            float f => FromDouble(f),
+            double d => FromDouble(d),
             string s => BicepSyntax.Value(s),
             Uri u => BicepSyntax.Value(ToLiteralString(u, format)),
             DateTimeOffset d => BicepSyntax.Value(ToLiteralString(d, format)),
@@ -121,6 +125,28 @@ IBicepValue v when (v.Kind == BicepValueKind.Unset) => BicepSyntax.Null(),
             _ => throw new InvalidOperationException($"Cannot convert {value} to a Bicep expression.")
         };
 
+        BicepExpression FromLong(long l)
+        {
+            // see if the value falls into the int range
+            if (l >= int.MinValue && l <= int.MaxValue)
+            {
+                return BicepSyntax.Value((int)l);
+            }
+            // otherwise we use the workaround from https://github.com/Azure/bicep/issues/1386#issuecomment-818077233
+            return BicepFunction.ParseJson(BicepSyntax.Value(l.ToString())).Compile();
+        }
+
+        BicepExpression FromDouble(double d)
+        {
+            // see if the value is a whole number
+            if (d >= int.MinValue && d <= int.MaxValue && d == Math.Floor(d))
+            {
+                return BicepSyntax.Value((int)d);
+            }
+            // otherwise we use the workaround from https://github.com/Azure/bicep/issues/1386#issuecomment-818077233
+            return BicepFunction.ParseJson(BicepSyntax.Value(d.ToString())).Compile();
+        }
+
         ArrayExpression ToArray(IEnumerable<object> seq) =>
             BicepSyntax.Array([.. seq.Select(v => ToBicep(v, v is BicepValue b ? b.Format : null))]);
 

sdk/provisioning/Azure.Provisioning/tests/BicepValues/BicepValueTests.cs

@@ -0,0 +1,48 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using NUnit.Framework;
+
+namespace Azure.Provisioning.Tests.BicepValues;
+
+public class BicepValueTests
+{
+    [Test]
+    public void ValidateLiteralBicepValue()
+    {
+        // string value
+        AssertExpression("'test'", new BicepValue<string>("test"));
+
+        // int value
+        AssertExpression("42", new BicepValue<int>(42));
+        AssertExpression("-42", new BicepValue<int>(-42));
+
+        // long value
+        AssertExpression("42", new BicepValue<long>(42L));
+        AssertExpression("2147483647", new BicepValue<long>(2147483647L));
+        AssertExpression("json('2147483648')", new BicepValue<long>(2147483648));
+        AssertExpression("-2147483648", new BicepValue<long>(-2147483648L));
+        AssertExpression("json('-2147483649')", new BicepValue<long>(-2147483649));
+        AssertExpression("json('9223372036854775807')", new BicepValue<long>(9223372036854775807));
+
+        // bool value
+        AssertExpression("true", new BicepValue<bool>(true));
+        AssertExpression("false", new BicepValue<bool>(false));
+
+        // double value
+        AssertExpression("json('3.14')", new BicepValue<double>(3.14));
+        AssertExpression("json('-3.14')", new BicepValue<double>(-3.14));
+        // double value with whole numbers
+        AssertExpression("314", new BicepValue<double>(314d));
+        AssertExpression("2147483647", new BicepValue<double>(2147483647d));
+        AssertExpression("json('2147483648')", new BicepValue<double>(2147483648d));
+        AssertExpression("-2147483647", new BicepValue<double>(-2147483647d));
+        AssertExpression("-2147483648", new BicepValue<double>(-2147483648d));
+        AssertExpression("json('-2147483649')", new BicepValue<double>(-2147483649d));
+
+        static void AssertExpression(string expected, BicepValue bicepValue)
+        {
+            Assert.AreEqual(expected, bicepValue.ToString());
+        }
+    }
+}