inref arguments imported as byref arguments in external libraries

[thinkbeforecoding]

Please provide a succinct description of the issue.

With net 8.0 rc2 installed, F# doesn't recognize inref parameters correctly and loads thems as byref.
This makes F# on net 8.0 unusable for some low level code 😬as it is impossible to create ReadOnlySpans etc..

Provide the steps required to reproduce the problem:

1. Create a global.json with version 8.0.100-rc.2.23502.2
2. Create a the following fsx script:

let f (x: int) =
    System.ReadOnlySpan(&x)

3. It reports the following error:

No overloads match for method 'ReadOnlySpan`1'.

Known type of argument: inref<int>

Available overloads:
 - ReadOnlySpan(array: 'a array) : ReadOnlySpan<'a> // Argument 'array' doesn't match
 - ReadOnlySpan(reference: byref<'a>) : ReadOnlySpan<'a> // Argument 'reference' doesn't match

Notice that the second overload should be of type inref<'a>
4. Replace version in global.json with 7.0.403 and reopen the script. There is no error.

You can test it with the System.Runtime.CompilerServices.Unsafe.AsRef as well.

Expected behavior

The argument type should be inref<'a> and there should be no error

Actual behavior

The argument type is byref<'a> which is incorrect. This seems to happen with all inref arguments.

Known workarounds

Stay on net6.0/net7.0 😬

Related information

Provide any related information (optional):

• Windows 11
• .NET Runtime kind: net 8.0 rc2
• Editing Tools: VS 2022 Version 17.8.0 Preview 7.0, VS Code

[thinkbeforecoding]

I noticed that this test should catch it:

fsharp/tests/FSharp.Compiler.ComponentTests/Interop/ByrefTests.fs

Line 17 in d441308

member this.SetValue(v: int) = (Unsafe.AsRef<int> &this.Value) <- v

But apparently, it doesn't...

[thinkbeforecoding]

Tried to look for similar issues, but only noticed #16252 now

Closing it as it will be fixed for release.

[vzarytovskii]

It's not going to be fixed in 8.0.100, probably following servicing release.

[thinkbeforecoding]

🫤, I know it's because of the BCL team that does not communicate breaking changes.
That's quite annoying they can do that.
thx @vzarytovskii for your quick fix!

[thinkbeforecoding]

I tried to Reimplement the Unsafe.AsRef function to work around the limitation as:

let inline asRef(x: 't inref) : 't byref = (# "" x : 't byref)

But it doesn't work... it tries to convert the value in x to a byref. And I can't write (# "" &x : 't byref)

[vzarytovskii]

I tried to Reimplement the Unsafe.AsRef function to work around the limitation as:

let inline asRef(x: 't inref) : 't byref = (# "" x : 't byref)

But it doesn't work... it tries to convert the value in x to a byref. And I can't write (# "" &x : 't byref)

Technically, for the Unsafe.As, something like this would work:

#nowarn "42"
open System.Runtime.CompilerServices
open Microsoft.FSharp.NativeInterop

type MyRecord = { Value : int } with
    member this.SetValue(v: int) =
        let ptr = NativePtr.toVoidPtr<int> &&this.Value
        (Unsafe.AsRef<int> ptr) <- v

let check mr =
    if mr.Value <> 1 then
        failwith "Value should be 1"

    mr.SetValue(42)

    if mr.Value <> 42 then
        failwith $"Value should be 42, but is {mr.Value}"
    0

let mr = { Value = 1 }
check mr

Since it does have a voidptr overload.

[thinkbeforecoding]

This works ! Thank you again! 🎉

[thinkbeforecoding]

Mh almost... the NativePtr.toVoidPtr has an unmanaged constraint, which is not the case with Unsafe.AsRef.
So I cannot use it for structs...