Optimize 'string', remove boxing where possible, prevent FS0670, simplify generic code (RFC-1089) (dotnet#9549)

* Merge from Re-enable-tests-for-operators

* Add tests that cover the changes for fixing FS0670

* Un-inline `string` to allow used in generic overrides and types

* Fix 3x C# default impl tests by removing dep. on FSharp.Core.dll

* Implement new 'string' ideas from RFC-1089

* Some housekeeping, adding IFormattable to the list

* Further optimizations for unsigned ints and (u)nativeint

* Adding back 'inline' but not SRTP

* Ignore NCrunch temp files and local user files

* Fix string of enum-of-char

* Fix tests in ExprTests.fs

* Distinguish between FSharp.Core 4.5, 4.6 and 4.7 in tests in ExprTests.fs

Author: abelbraaksma

src/fsharp/FSharp.Core/prim-types.fs

@@ -784,9 +784,9 @@ namespace Microsoft.FSharp.Core
 
         let inline anyToString nullStr x = 
             match box x with 
+            | :? IFormattable as f -> f.ToString(null, CultureInfo.InvariantCulture)
             | null -> nullStr
-            | :? System.IFormattable as f -> f.ToString(null,System.Globalization.CultureInfo.InvariantCulture)
-            | obj ->  obj.ToString()
+            | _ ->  x.ToString()
 
         let anyToStringShowingNull x = anyToString "null" x
 
@@ -3749,6 +3749,8 @@ namespace Microsoft.FSharp.Core
     open System.Diagnostics              
     open System.Collections.Generic
     open System.Globalization
+    open System.Text
+    open System.Numerics
     open Microsoft.FSharp.Core
     open Microsoft.FSharp.Core.LanguagePrimitives
     open Microsoft.FSharp.Core.LanguagePrimitives.IntrinsicOperators
@@ -4456,23 +4458,53 @@ namespace Microsoft.FSharp.Core
              when ^T : ^T = (^T : (static member op_Explicit: ^T -> nativeint) (value))
 
         [<CompiledName("ToString")>]
-        let inline string (value: ^T) = 
+        let inline string (value: 'T) = 
              anyToString "" value
-             // since we have static optimization conditionals for ints below, we need to special-case Enums.
-             // This way we'll print their symbolic value, as opposed to their integral one (Eg., "A", rather than "1")
-             when ^T struct = anyToString "" value
-             when ^T : float      = (# "" value : float      #).ToString("g",CultureInfo.InvariantCulture)
-             when ^T : float32    = (# "" value : float32    #).ToString("g",CultureInfo.InvariantCulture)
-             when ^T : int64      = (# "" value : int64      #).ToString("g",CultureInfo.InvariantCulture)
-             when ^T : int32      = (# "" value : int32      #).ToString("g",CultureInfo.InvariantCulture)
-             when ^T : int16      = (# "" value : int16      #).ToString("g",CultureInfo.InvariantCulture)
-             when ^T : nativeint  = (# "" value : nativeint  #).ToString()
-             when ^T : sbyte      = (# "" value : sbyte      #).ToString("g",CultureInfo.InvariantCulture)
-             when ^T : uint64     = (# "" value : uint64     #).ToString("g",CultureInfo.InvariantCulture)
-             when ^T : uint32     = (# "" value : uint32     #).ToString("g",CultureInfo.InvariantCulture)
-             when ^T : int16      = (# "" value : int16      #).ToString("g",CultureInfo.InvariantCulture)
-             when ^T : unativeint = (# "" value : unativeint #).ToString()
-             when ^T : byte       = (# "" value : byte       #).ToString("g",CultureInfo.InvariantCulture)
+             when 'T : string     = (# "" value : string #)     // force no-op
+
+             // Using 'let x = (# ... #) in x.ToString()' leads to better IL, without it, an extra stloc and ldloca.s (get address-of)
+             // gets emitted, which are unnecessary. With it, the extra address-of-variable is not created
+             when 'T : float      = let x = (# "" value : float #)      in x.ToString(null, CultureInfo.InvariantCulture)
+             when 'T : float32    = let x = (# "" value : float32 #)    in x.ToString(null, CultureInfo.InvariantCulture)
+             when 'T : decimal    = let x = (# "" value : decimal #)    in x.ToString(null, CultureInfo.InvariantCulture)
+             when 'T : BigInteger = let x = (# "" value : BigInteger #) in x.ToString(null, CultureInfo.InvariantCulture)
+             
+             // no IFormattable
+             when 'T : char       = let x = (# "" value : 'T #)         in x.ToString()     // use 'T, because char can be an enum  
+             when 'T : bool       = let x = (# "" value : bool #)       in x.ToString()
+             when 'T : nativeint  = let x = (# "" value : nativeint #)  in x.ToString()
+             when 'T : unativeint = let x = (# "" value : unativeint #) in x.ToString()
+
+             // Integral types can be enum:
+             // It is not possible to distinguish statically between Enum and (any type of) int. For signed types we have 
+             // to use IFormattable::ToString, as the minus sign can be overridden. Using boxing we'll print their symbolic
+             // value if it's an enum, e.g.: 'ConsoleKey.Backspace' gives "Backspace", rather than "8")
+             when 'T : sbyte      = (box value :?> IFormattable).ToString(null, CultureInfo.InvariantCulture)
+             when 'T : int16      = (box value :?> IFormattable).ToString(null, CultureInfo.InvariantCulture)
+             when 'T : int32      = (box value :?> IFormattable).ToString(null, CultureInfo.InvariantCulture)
+             when 'T : int64      = (box value :?> IFormattable).ToString(null, CultureInfo.InvariantCulture)
+
+             // unsigned integral types have equal behavior with 'T::ToString() vs IFormattable::ToString
+             // this allows us to issue the 'constrained' opcode with 'callvirt'
+             when 'T : byte       = let x = (# "" value : 'T #) in x.ToString()
+             when 'T : uint16     = let x = (# "" value : 'T #) in x.ToString()
+             when 'T : uint32     = let x = (# "" value : 'T #) in x.ToString()
+             when 'T : uint64     = let x = (# "" value : 'T #) in x.ToString()
+
+
+             // other common mscorlib System struct types
+             when 'T : DateTime         = let x = (# "" value : DateTime #) in x.ToString(null, CultureInfo.InvariantCulture)
+             when 'T : DateTimeOffset   = let x = (# "" value : DateTimeOffset #) in x.ToString(null, CultureInfo.InvariantCulture)
+             when 'T : TimeSpan         = let x = (# "" value : TimeSpan #) in x.ToString(null, CultureInfo.InvariantCulture)
+             when 'T : Guid             = let x = (# "" value : Guid #) in x.ToString(null, CultureInfo.InvariantCulture)
+             when 'T struct = 
+                match box value with
+                | :? IFormattable as f -> f.ToString(null, CultureInfo.InvariantCulture)
+                | _ -> value.ToString()
+
+             // other commmon mscorlib reference types
+             when 'T : StringBuilder = let x = (# "" value : StringBuilder #) in x.ToString()
+             when 'T : IFormattable = let x = (# "" value : IFormattable #) in x.ToString(null, CultureInfo.InvariantCulture)
 
         [<NoDynamicInvocation(isLegacy=true)>]
         [<CompiledName("ToChar")>]

src/fsharp/FSharp.Core/prim-types.fsi

@@ -3407,13 +3407,13 @@ namespace Microsoft.FSharp.Core
 
         /// <summary>Converts the argument to a string using <c>ToString</c>.</summary>
         ///
-        /// <remarks>For standard integer and floating point values the <c>ToString</c> conversion 
-        /// uses <c>CultureInfo.InvariantCulture</c>. </remarks>
+        /// <remarks>For standard integer and floating point values the and any type that implements <c>IFormattable</c>
+        /// <c>ToString</c> conversion uses <c>CultureInfo.InvariantCulture</c>. </remarks>
         /// <param name="value">The input value.</param>
         ///
         /// <returns>The converted string.</returns>
         [<CompiledName("ToString")>]
-        val inline string  : value:^T -> string
+        val inline string  : value:'T -> string
 
         /// <summary>Converts the argument to System.Decimal using a direct conversion for all 
         /// primitive numeric types. For strings, the input is converted using <c>UInt64.Parse()</c>  

tests/FSharp.Core.UnitTests/FSharp.Core/OperatorsModule2.fs

@@ -8,6 +8,19 @@ namespace FSharp.Core.UnitTests.Operators
 open System
 open FSharp.Core.UnitTests.LibraryTestFx
 open NUnit.Framework
+open System.Globalization
+open System.Threading
+
+/// If this type compiles without error it is correct
+/// Wrong if you see: FS0670 This code is not sufficiently generic. The type variable ^T could not be generalized because it would escape its scope.
+type TestFs0670Error<'T> =
+    | TestFs0670Error of 'T
+    override this.ToString() =
+        match this with
+        | TestFs0670Error x -> 
+            // This used to raise FS0670 because the type is generic, and 'string' was inline
+            // See: https://github.com/dotnet/fsharp/issues/7958
+            Operators.string x
 
 [<TestFixture>]
 type OperatorsModule2() =
@@ -732,6 +745,53 @@ type OperatorsModule2() =
         // reference type
         let result = Operators.string "ABC"
         Assert.AreEqual("ABC", result)
+
+        // reference type without a `ToString()` overload
+        let result = Operators.string (obj())
+        Assert.AreEqual("System.Object", result)
+
+        let result = Operators.string 1un
+        Assert.AreEqual("1", result)
+
+        let result = Operators.string (obj())
+        Assert.AreEqual("System.Object", result)
+
+        let result = Operators.string 123.456M
+        Assert.AreEqual("123.456", result)
+
+        // Following tests ensure that InvariantCulture is used if type implements IFormattable
+        
+        // safe current culture, then switch culture
+        let currentCI = Thread.CurrentThread.CurrentCulture
+        Thread.CurrentThread.CurrentCulture <- CultureInfo.GetCultureInfo("de-DE")
+
+        // make sure the culture switch happened, and verify
+        let wrongResult = 123.456M.ToString()
+        Assert.AreEqual("123,456", wrongResult)
+
+        // test that culture has no influence on decimals with `string`
+        let correctResult = Operators.string 123.456M
+        Assert.AreEqual("123.456", correctResult)
+
+        // make sure that the German culture is indeed selected for DateTime
+        let dttm = DateTime(2020, 6, 23)
+        let wrongResult = dttm.ToString()
+        Assert.AreEqual("23.06.2020 00:00:00", wrongResult)
+
+        // test that culture has no influence on DateTime types when used with `string`
+        let correctResult = Operators.string dttm
+        Assert.AreEqual("06/23/2020 00:00:00", correctResult)
+
+        // reset the culture
+        Thread.CurrentThread.CurrentCulture <- currentCI
+
+    [<Test>]
+    member _.``string: don't raise FS0670 anymore``() =
+        // The type used here, when compiled, should not raise this error:
+        // "FS0670 This code is not sufficiently generic. The type variable ^T could not be generalized because it would escape its scope."
+        // See: https://github.com/dotnet/fsharp/issues/7958
+        let result = TestFs0670Error 32uy |> Operators.string
+        Assert.AreEqual("32", result)
 
     [<Test>]
     member _.tan() =

tests/fsharp/Compiler/Language/DefaultInterfaceMemberTests.fs

@@ -810,15 +810,15 @@ type Test () =
         member __.M(_x: int) = Console.Write("InTest")
 
         member __.M<'Item> (x: int, y: 'Item) = 
-            Console.Write(string x)
+            Console.Write(x.ToString())
             Console.Write(y.ToString ())
 
         member __.M<'TTT> (x: 'TTT) =
             Console.Write(x.ToString ())
 
         member __.M (x: int, text: string) =
             Console.Write("ABC")
-            Console.Write(string x)
+            Console.Write(x.ToString())
             Console.Write(text)
 
         member __.M<'U> (_x: 'U, _y: int) = ()
@@ -1166,7 +1166,8 @@ type Test () =
 let main _ =
     let x = Test () :> I1
     let y = Test () :> I2
-    Console.Write(string (x + y))
+    let result = x + y
+    Console.Write(result.ToString())
     0
             """
 
@@ -4229,15 +4230,15 @@ type Test () =
         member __.M(_x: int) = Console.Write("InTest")
 
         member __.M<'Item> (x: int, y: 'Item) = 
-            Console.Write(string x)
+            Console.Write(x.ToString())
             Console.Write(y.ToString ())
 
         member __.M<'TTT> (x: 'TTT) =
             Console.Write(x.ToString ())
 
         member __.M (x: int, text: string) =
             Console.Write("ABC")
-            Console.Write(string x)
+            Console.Write(x.ToString())
             Console.Write(text)
 
 type Test2 () =