Parenthesized/double unit literal `()` → `(())` required in certain scenarios

[brianrourkeboll]

A parenthesized unit literal () → (()) is required as an argument pattern when overriding/implementing a generic method where unit is the generic type argument.

Repro steps

Provide the steps required to reproduce the problem:

1. Define an abstract method whose single argument is a generic type (abstract M : 'T -> …).
2. When implementing or overriding the method when the generic type parameter is unit, the argument pattern must be (()); using only () yields error FS0768: The member 'M' does not accept the correct number of arguments. 1 argument(s) are expected, but 0 were given.

Single () usually means unit

type C = abstract M : unit -> unit
let _ = { new C with override _.M () = () }

Double (()) is required when overriding/implementing a generic method where unit is the generic type argument

Double (()) compiles:

type C<'T> = abstract M : 'T -> unit
let _ = { new C<unit> with override _.M (()) = () }

but not ():

let _ = { new C<unit> with override _.M () = () }
------------------------------------^^^^^^

stdin(3,37): error FS0768: The member 'M' does not accept the correct number of arguments. 1 argument(s) are expected, but 0 were given. The required signature is 'C.M: 'T -> unit'.

even though this is fine:

type C<'T> = abstract M : 'T * 'T -> unit
let c = { new C<unit> with override _.M ((), ()) = () }

as is

type C<'T> = abstract M : 'T -> 'T -> unit
let c = { new C<unit> with override _.M () () = () }

Expected behavior

() should mean unit everywhere.

Actual behavior

(()) is required to represent unit in certain scenarios.

Known workarounds

N/A.

Related information

.NET SDK 8.0.100-rc.2.23502.2 (and probably going far back—I remember running into this in years past).

[brianrourkeboll]

@psfinaki Hmm, it looks like by "linking" this to #16262, this issue will be closed when that PR is merged:

But (as you know) that PR doesn't actually address the inconsistency in the compiler; it just works around it for the unnecessary parentheses analyzer and code fix. Same with #16257.

[0101]

Since () also means calling a method with no arguments, this could be complicated to fix. Since this is quite the corner case maybe it's enough to improve the error message.

[brianrourkeboll]

Hmm, it looks like this is where it happens:

fsharp/src/Compiler/Checking/CheckExpressions.fs

Lines 6752 to 6794 in 75cd8c7

	and FreshenObjExprAbstractSlot (cenv: cenv) (env: TcEnv) (implTy: TType) virtNameAndArityPairs (bind, bindAttribs, bindName, absSlots:(_ * MethInfo) list) =
	let g = cenv.g
	let (NormalizedBinding (typars=synTyparDecls; mBinding=mBinding)) = bind
	match absSlots with
	| [] when not (CompileAsEvent g bindAttribs) ->
	let absSlotsByName = List.filter (fst >> fst >> (=) bindName) virtNameAndArityPairs
	let getSignature absSlot = (NicePrint.stringOfMethInfo cenv.infoReader mBinding env.DisplayEnv absSlot).Replace("abstract ", "")
	let getDetails (absSlot: MethInfo) =
	if absSlot.GetParamTypes(cenv.amap, mBinding, []) |> List.existsSquared (isAnyTupleTy g) then
	FSComp.SR.tupleRequiredInAbstractMethod()
	else ""
	// Compute the argument counts of the member arguments
	let _, synValInfo = GetNameAndSynValInfoOfObjExprBinding cenv env bind
	let arity =
	match SynInfo.AritiesOfArgs synValInfo with
	| _ :: x :: _ -> x
	| _ -> 0
	match absSlotsByName with
	| [] ->
	let tcref = tcrefOfAppTy g implTy
	let containsNonAbstractMemberWithSameName =
	tcref.MembersOfFSharpTyconByName
	|> Seq.exists (fun kv -> kv.Value |> List.exists (fun valRef -> valRef.DisplayName = bindName))
	let suggestVirtualMembers (addToBuffer: string -> unit) =
	for (x, _), _ in virtNameAndArityPairs do
	addToBuffer x
	if containsNonAbstractMemberWithSameName then
	errorR(ErrorWithSuggestions(FSComp.SR.tcMemberFoundIsNotAbstractOrVirtual(tcref.DisplayName, bindName), mBinding, bindName, suggestVirtualMembers))
	else
	errorR(ErrorWithSuggestions(FSComp.SR.tcNoAbstractOrVirtualMemberFound bindName, mBinding, bindName, suggestVirtualMembers))
	| [ (_, absSlot: MethInfo) ] ->
	errorR(Error(FSComp.SR.tcArgumentArityMismatch(bindName, List.sum absSlot.NumArgs, arity, getSignature absSlot, getDetails absSlot), mBinding))
	| (_, absSlot) :: _ ->
	errorR(Error(FSComp.SR.tcArgumentArityMismatchOneOverload(bindName, List.sum absSlot.NumArgs, arity, getSignature absSlot, getDetails absSlot), mBinding))

specifically

fsharp/src/Compiler/Checking/CheckExpressions.fs

Line 6760 in 75cd8c7

let absSlotsByName = List.filter (fst >> fst >> (=) bindName) virtNameAndArityPairs

and

fsharp/src/Compiler/Checking/CheckExpressions.fs

Lines 6790 to 6791 in 75cd8c7

	| [ (_, absSlot: MethInfo) ] ->
	errorR(Error(FSComp.SR.tcArgumentArityMismatch(bindName, List.sum absSlot.NumArgs, arity, getSignature absSlot, getDetails absSlot), mBinding))

My guess is that some kind of tweak could be made to the filter above or in here (the callsite of the above) to account for unit:

fsharp/src/Compiler/Checking/CheckExpressions.fs

Lines 6912 to 6927 in 75cd8c7

	let bindNameAndSynInfoPairs = binds |> List.map (GetNameAndSynValInfoOfObjExprBinding cenv env)
	let bindNames = bindNameAndSynInfoPairs |> List.map fst
	let bindKeys =
	bindNameAndSynInfoPairs |> List.map (fun (name, valSynData) ->
	// Compute the argument counts of the member arguments
	let argCounts = (SynInfo.AritiesOfArgs valSynData).Tail
	//dprintfn "name = %A, argCounts = %A" name argCounts
	(name, argCounts))
	// 3. infer must-have types by name/arity
	let preAssignedVirtsPerBinding =
	bindKeys |> List.map (fun bkey -> List.filter (fst >> (=) bkey) virtNameAndArityPairs)
	let absSlotInfo =
	(List.zip4 binds bindsAttributes bindNames preAssignedVirtsPerBinding)
	|> List.map (FreshenObjExprAbstractSlot cenv env implTy virtNameAndArityPairs)

Although we'd obviously need to make sure any change there didn't break anything else.

[vzarytovskii]

@brianrourkeboll
What's the proposed solution?

Specifically, what happens in the following scenario if we decide that () is equivalent to () in case of generic method.

type C<'T> =
    abstract M : unit -> unit
    abstract M : 'T -> unit
let _ =
  { 
    new C<unit> with
      override _.M () = ()
      override _.M (()) = ()
  }