Interpolated string issue on Thai culture

[iminashi]

There appears to be a bug where (at least) on Thai culture settings, closing parentheses appear into interpolated strings. Seems to be an F# specific issue?

Repro steps

open System.Globalization
open System.Threading

type Test = { Name: string } with override this.ToString() = this.Name

let staticString = "Static string"
let number = 1.5
let obj = { Name = "Test" }

Thread.CurrentThread.CurrentCulture <- CultureInfo("th")

let interpolated1 = $"{obj} {number} {staticString}"
let interpolated2 = $"%O{obj} %O{number} %s{staticString}"
let formatted = sprintf "%O %O %s" obj number staticString

printfn "%s" interpolated1
printfn "%s" interpolated2
printfn "%s" formatted

Expected behavior

Prints:

Test 1.5 Static string
Test 1.5 Static string
Test 1.5 Static string

Actual behavior

Prints:

Test) 1.5) Static string)
Test 1.5 Static string
Test 1.5 Static string

Known workarounds

As in the above example, using format specifiers appears to prevent this.

Related information

• Windows 11

[brianrourkeboll]

Here is a more fun minimal repro:

open System.Globalization

CultureInfo.CurrentCulture <- CultureInfo.GetCultureInfo "th"
let s = $"%P({3})"
// System.IndexOutOfRangeException: Index was outside the bounds of the array.
//    at Microsoft.FSharp.Core.PrintfImpl.PrintfEnv`3.RunSteps(Object[] args, Type[] argTys, Step[] steps) in D:\a\_work\1\s\src\FSharp.Core\printf.fs:line 327
//    at Microsoft.FSharp.Core.PrintfModule.PrintFormatToStringThen[T](PrintfFormat`4 format) in D:\a\_work\1\s\src\FSharp.Core\printf.fs:line 1420

The bug appears to be the culture-dependent call to IndexOf here:

fsharp/src/FSharp.Core/printf.fs

Lines 209 to 222 in 6e28aa3

	let parseInterpolatedHoleDotNetFormat typeChar (s: string) (i: byref<int>) =
	if typeChar = 'P' then
	if i < s.Length && s.[i] = '(' then
	let i2 = s.IndexOf(")", i)
	if i2 = -1 then
	ValueNone
	else
	let res = s.[i+1..i2-1]
	i <- i2+1
	ValueSome res
	else
	ValueNone
	else
	ValueNone

In Thai, apparently all punctuation compares equal:

String.Compare ("{", ")", CultureInfo.GetCultureInfo "th", CompareOptions.None) // 0

The fix would be to make it use ordinal comparison, or to call the overload of IndexOf that takes a char instead of a string.

Example

open System
open System.Globalization

let test version parse =
    printfn $"{version}"
    let orig = CultureInfo.CurrentCulture
    CultureInfo.CurrentCulture <- CultureInfo.GetCultureInfo "en-US"
    let enUs = parse 'P' "%P({3})" 2    // ValueSome "{3}"
    CultureInfo.CurrentCulture <- CultureInfo.GetCultureInfo "th"
    let th   = parse 'P' "%P({3})" 2    // ValueSome "{3}"
    printfn $"en-US: {enUs}"
    printfn $"th:    {th}"
    CultureInfo.CurrentCulture <- orig

let parseInterpolatedHoleDotNetFormat_Broken typeChar (s: string) (i: int) =
    if typeChar = 'P' then 
        if i < s.Length && s.[i] = '(' then  
             let i2 = s.IndexOf(")", i)
             if i2 = -1 then 
                 ValueNone
             else 
                 let res = s.[i+1..i2-1]
                 // i <- i2+1
                 ValueSome res
        else
            ValueNone
    else
        ValueNone

let parseInterpolatedHoleDotNetFormat_Fixed typeChar (s: string) (i: int) =
    if typeChar = 'P' then 
        if i < s.Length && s.[i] = '(' then  
             let i2 = s.IndexOf(")", i, StringComparison.Ordinal)
             if i2 = -1 then 
                 ValueNone
             else 
                 let res = s.[i+1..i2-1]
                 // i <- i2+1
                 ValueSome res
        else
            ValueNone
    else
        ValueNone

test "Broken" parseInterpolatedHoleDotNetFormat_Broken
test "Fixed" parseInterpolatedHoleDotNetFormat_Fixed
//Broken
//en-US: {3})
//th:    )
//Fixed
//en-US: {3})
//th:    {3})

Too bad #16066 never got merged, because it would have fixed this :)