When struct val field name equals constructor argument "ambiguous overload"

[NinoFloris]

When struct val field name equals constructor argument "ambiguous overload"

open System

[<Struct>]
type C =
    val private x: int
    new (x) = { x = x }

//error FS0041: A unique overload for method 'C' could not be determined based on type information 
// prior to this program point. A type annotation may be needed. Candidates: C (), new : x:int -> C    
let test = C(x = 0)

https://sharplab.io/#v2:EYLgxg9gTgpgtADwGwBYA0AbEAzAzgHwgAcYA7AAgGUBPXAFxgFsBYAKDbYG0AeSuqAK5g6APgC6bOtRLkAwuQC8bcivIA3AIYZyRKAEtNDcghDk9pOstWkYAd3IAKBAEpF5AN7G3CcgF8rKmwYMHTkDPRusk5uAAzOQA===

Changing new (x) to say new (y) (and its references) allows the resolution to succeed. ¯\(ツ)/¯

[abelbraaksma]

I've been hit by this too, I think it's caused by the compiler thinking it's a field assignment for field x, vs a boolean expression. I've reported that somewhere as well, let me see if I can find it back.

[abelbraaksma]

Hmm, not sure it's related, but it seems in the same ballpark: #9517

My hunch is that it has the same cause.

[NinoFloris]

Changed it to int as it has nothing to do with boolean expression confusion :) I think indeed there is some field and constructor argument confusion going on but it does not seem too related to #9517

[cartermp]

Worth noting that this has no issue, which I expect to be the usual case:

open System

[<Struct>]
type C =
    val private x: int
    new (x) = { x = x }

let test = C(0)

Seems like a reasonable thing to also allow the named argument here

[NinoFloris]

@cartermp this is mostly problematic when there are multiple constructors, of which at least one is for a generic field.
At that point F# will report an ambiguous overload anyway (because there is no tiebreaker for it) and there's no way to disambiguate on name either if you're dealing with a type like I showed, at that point you have no other options :)

[heronbpv]

Is it possible to use a self reference in the constructor definition, to help disambiguate?

[dsyme]

So do we agree this is legitimately considered ambiguous?

open System

[<Struct>]
type C =
    val mutable x: int
    new (x) = { x = x }

let test = C(x = 0)

Here x = 0 may be a named argument or named field assignment.

In this case, the issue is that the private on val private x: int is not being taken into account during pre-analysis of the method call. I guess it's reasonable to take it into account, and also to check if the field is mutable or not.

[NinoFloris]

I would indeed say it's ambiguous without the private access modifier