Skip to content

Record the parameter and type parameter counts of a navigable item #20531

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
xperiandri wants to merge 4 commits into
base: main
Choose a base branch
from
Open

Record the parameter and type parameter counts of a navigable item #20531

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
5a8cc99
Record the parameter and type parameter counts of a navigable item
xperiandri Sep 13, 2026
f1b560c
Link the release note to its PR
xperiandri Sep 13, 2026
bfb2486
Count a named unit argument of a signature as no argument
xperiandri Sep 26, 2026
86cfab8
Move the release note to the version in development
xperiandri Sep 26, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions docs/release-notes/.FSharp.Compiler.Service/11.0.200.md
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,6 +1,7 @@
### Added

* F# Interactive gains a JSON-RPC server mode, `--fsi-server-jsonrpc:<pipe name>`, in which a host submits interactions over a named pipe and receives structured results — diagnostics with positions, escaping exceptions, the values each interaction bound, and the session's own process id — instead of recovering them by looking for a `SERVER-PROMPT>` marker in the output text. Program output continues to flow through the redirected console streams. The pipe admits only the user running the session; `--fsi-server-client-pid:<pid>` names the host process whose exit ends the session. `FsiEvaluationSession` exposes both options as `JsonRpcServerPipeName` and `JsonRpcClientProcessId`. The mode is part of the .NET fsi only. ([PR #20396](https://github.com/dotnet/fsharp/pull/20396))
* `NavigableItem` carries `ParameterCount` and `TypeParameterCount`, the counts C# and VB give Navigate To to order matches that are otherwise equal. ([PR #20531](https://github.com/dotnet/fsharp/pull/20531))

### Fixed

Expand Down
65 changes: 56 additions & 9 deletions src/Compiler/Service/ServiceNavigation.fs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -764,10 +764,39 @@ type NavigableItem =
IsSignature: bool
Kind: NavigableItemKind
Container: NavigableContainer
ParameterCount: int
TypeParameterCount: int
}

[<RequireQualifiedAccess>]
module NavigateTo =
let private typeParameterCountOf (typars: SynTyparDecls option) =
match typars with
| Some typars -> typars.TyparDecls.Length
| None -> 0

let rec private isUnitType synType =
match synType with
| SynType.LongIdent(SynLongIdent([ id ], _, _)) -> id.idText = "unit"
| SynType.Paren(innerType, _)
| SynType.WithGlobalConstraints(innerType, _, _)
// `val f: u: unit -> int` names the argument the compiler drops, so the name must not hide it.
| SynType.SignatureParameter(usedType = innerType) -> isUnitType innerType
| _ -> false

@T-Gro T-Gro Sep 14, 2026

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🤖 🕵️ Named unit parameter counted as 1 in the signature but 0 in the implementation — different Navigate To sort keys for the same zero-argument method.

// NamedUnit.fsi
module NamedUnit
val Search : u: unit -> int

// NamedUnit.fs
module NamedUnit
let Search () = 1

@xperiandri xperiandri Sep 26, 2026

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in bfb24868a5. The check that drops a solitary unit looked through SynType.Paren and SynType.WithGlobalConstraints but not through SynType.SignatureParameter, so naming the argument hid it: val Search : u: unit -> int counted one where let Search () = 1 counted none.

isUnitType sees through the named form now, and NavigateToTests covers it — the signature fixture gained val takesNamedUnit: u: unit -> int and asserts (0, 0), next to the unnamed takesUnit that was already there. 32 tests pass across both target frameworks.


/// The parameters of the compiled method: the parser leaves a solitary unit argument of a signature in its arity,
/// where a binding has already dropped it.
let private parameterCountOfSignature (SynValInfo(curriedArgInfos, _)) (synType: SynType) =

@T-Gro T-Gro Sep 21, 2026

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I am afraid this might alltogether operate on a wrong layer, considering things like:

  • unit
  • byrefs
  • units of measure

This should follow existing functions that know how a function is represented in IL.

@xperiandri xperiandri Sep 26, 2026

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The layer is forced by what the caller is: NavigateTo.GetNavigableItems runs on a parse tree alone. Navigate To has to answer for every document in the solution, and it has to answer while the solution is still loading, so no checking has happened and there is no Val, no TType, nothing the arity functions (GetTopValTypeInFSharpForm, ArgInfosOfMember) could be handed. Reaching for them here would mean checking every document in the solution to fill in a sort tiebreak.

That is also the layer the numbers are compared against. They exist for NavigateToSearchResultHelpers.ComputeSecondarySort, which orders results that already matched the pattern equally well, and C# and Visual Basic fill them the same way — CSharpDeclaredSymbolInfoFactoryService takes ParameterList.Parameters.Count and TypeParameterList?.Parameters.Count straight off the declaration syntax. A wrong count moves one same-named result past another in that list; it is never asked whether two members are the same member.

On the three you named:

  • byrefs — a byref parameter is still one parameter in IL, so the count is unaffected;
  • units of measure — a measure annotates the type of a parameter and adds none, so likewise;
  • unit — this one really does differ, and it is the only one that does. A solitary unit argument is dropped by the compiler but left in the arity the parser produces for a signature, so val f : unit -> int and let f () = 1 disagreed. That is handled.

The remaining hole is the named form the bot found in the other thread, val Search : u: unit -> int: the check looks through SynType.Paren and SynType.WithGlobalConstraints but not through SynType.SignatureParameter, so a named unit still counts as one. Fixing that, and adding both spellings to the tests.

If the team would rather the two numbers be IL-accurate, then they cannot come from this walker at all and the tiebreak needs a different source — happy to take that route instead, but it is a different change from this one.

match curriedArgInfos, synType with
| [ [ _ ] ], SynType.Fun(argType = argType) when isUnitType argType -> 0
| [ [ _ ] ], SynType.WithGlobalConstraints(SynType.Fun(argType = argType), _, _) when isUnitType argType -> 0
| _ -> List.sumBy List.length curriedArgInfos

let private parameterCountOfBinding (SynValData(memberFlags = memberFlags; valInfo = SynValInfo(curriedArgInfos, _))) =
match memberFlags, curriedArgInfos with
| Some memberFlags, _self :: argInfos when memberFlags.IsInstance -> List.sumBy List.length argInfos
| _ -> List.sumBy List.length curriedArgInfos

let GetNavigableItems (parsedInput: ParsedInput) : NavigableItem[] =

let convertToDisplayName name =
Expand All @@ -778,7 +807,7 @@ module NavigateTo =

let result = ResizeArray()

let addLongIdent kind (lid: LongIdent) (isSignature: bool) (container: NavigableContainer) =
let addLongIdent kind (lid: LongIdent) (isSignature: bool) (container: NavigableContainer) typeParameterCount =
if not lid.IsEmpty then
let name = textOfLid lid

Expand All @@ -789,10 +818,12 @@ module NavigateTo =
IsSignature = isSignature
Kind = kind
Container = container
ParameterCount = 0
TypeParameterCount = typeParameterCount
}
|> result.Add

let addIdent kind (id: Ident) (isSignature: bool) (container: NavigableContainer) =
let addIdentWithArity kind (id: Ident) (isSignature: bool) (container: NavigableContainer) parameterCount typeParameterCount =
if not (String.IsNullOrEmpty id.idText) then
let name = convertToDisplayName id.idText

Expand All @@ -803,11 +834,16 @@ module NavigateTo =
IsSignature = isSignature
Kind = kind
Container = container
ParameterCount = parameterCount
TypeParameterCount = typeParameterCount
}
|> result.Add

let addIdent kind id isSignature container =
addIdentWithArity kind id isSignature container 0 0

let addModule lid isSig container =
addLongIdent NavigableItemKind.Module lid isSig container
addLongIdent NavigableItemKind.Module lid isSig container 0

let addModuleAbbreviation (id: Ident) isSig container =
addIdent NavigableItemKind.ModuleAbbreviation id isSig container
Expand All @@ -818,14 +854,17 @@ module NavigateTo =
NavigableContainer.Container(NavigableContainerType.Exception, [ id.idText ], container)

let addComponentInfo containerType kind (info: SynComponentInfo) isSig container =
let (SynComponentInfo(typeParams = typeParams)) = info
let lid = info.LongIdent
addLongIdent kind lid isSig container
addLongIdent kind lid isSig container (typeParameterCountOf typeParams)

NavigableContainer.Container(containerType, pathOfLid lid, container)

let addValSig kind synValSig isSig container =
let (SynValSig(ident = SynIdent(id, _))) = synValSig
addIdent kind id isSig container
let (SynValSig(ident = SynIdent(id, _); explicitTypeParams = SynValTyparDecls(typars, _); synType = synType; arity = arity)) =
synValSig

addIdentWithArity kind id isSig container (parameterCountOfSignature arity synType) (typeParameterCountOf typars)

let addField synField isSig container =
let (SynField(idOpt = id)) = synField
Expand Down Expand Up @@ -863,17 +902,25 @@ module NavigateTo =
| Some mf -> mapMemberKind mf.MemberKind
| _ -> NavigableItemKind.ModuleValue

let typeParameterCount =
match headPat with
| SynPat.LongIdent(typarDecls = Some(SynValTyparDecls(typars, _))) -> typeParameterCountOf typars
| _ -> 0

let addBindingIdent id =
addIdentWithArity kind id false container (parameterCountOfBinding valData) typeParameterCount

match headPat with
| SynPat.LongIdent(longDotId = SynLongIdent([ _; id ], _, _)) ->
// instance members
addIdent kind id false container
addBindingIdent id
| SynPat.LongIdent(longDotId = SynLongIdent([ id ], _, _)) ->
// functions
addIdent kind id false container
addBindingIdent id
| SynPat.Named(SynIdent(id, _), _, _, _)
| SynPat.As(_, SynPat.Named(SynIdent(id, _), _, _, _), _) ->
// values
addIdent kind id false container
addBindingIdent id
| _ -> ()

let addMember valSig (memberFlags: SynMemberFlags) isSig container =
Expand Down
20 changes: 14 additions & 6 deletions src/Compiler/Service/ServiceNavigation.fsi
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -112,12 +112,20 @@ type NavigableContainer =
member Name: string

type NavigableItem =
{ Name: string
NeedsBackticks: bool
Range: range
IsSignature: bool
Kind: NavigableItemKind
Container: NavigableContainer }
{
Name: string
NeedsBackticks: bool
Range: range
IsSignature: bool
Kind: NavigableItemKind
Container: NavigableContainer
/// The number of parameters of the method the declaration compiles to, as C# and VB count them to order
/// equally good Navigate To matches: every curried and tupled argument, without the instance and without a
/// solitary unit argument.
ParameterCount: int
/// The number of explicitly declared type parameters.
TypeParameterCount: int
}

[<RequireQualifiedAccess>]
module public NavigateTo =
Expand Down
6 changes: 5 additions & 1 deletion tests/FSharp.Compiler.Service.Tests/FSharp.Compiler.Service.SurfaceArea.netstandard20.bsl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3949,10 +3949,14 @@ FSharp.Compiler.EditorServices.NavigableItem: FSharp.Compiler.Text.Range Range
FSharp.Compiler.EditorServices.NavigableItem: FSharp.Compiler.Text.Range get_Range()
FSharp.Compiler.EditorServices.NavigableItem: Int32 GetHashCode()
FSharp.Compiler.EditorServices.NavigableItem: Int32 GetHashCode(System.Collections.IEqualityComparer)
FSharp.Compiler.EditorServices.NavigableItem: Int32 ParameterCount
FSharp.Compiler.EditorServices.NavigableItem: Int32 TypeParameterCount
FSharp.Compiler.EditorServices.NavigableItem: Int32 get_ParameterCount()
FSharp.Compiler.EditorServices.NavigableItem: Int32 get_TypeParameterCount()
FSharp.Compiler.EditorServices.NavigableItem: System.String Name
FSharp.Compiler.EditorServices.NavigableItem: System.String ToString()
FSharp.Compiler.EditorServices.NavigableItem: System.String get_Name()
FSharp.Compiler.EditorServices.NavigableItem: Void .ctor(System.String, Boolean, FSharp.Compiler.Text.Range, Boolean, FSharp.Compiler.EditorServices.NavigableItemKind, FSharp.Compiler.EditorServices.NavigableContainer)
FSharp.Compiler.EditorServices.NavigableItem: Void .ctor(System.String, Boolean, FSharp.Compiler.Text.Range, Boolean, FSharp.Compiler.EditorServices.NavigableItemKind, FSharp.Compiler.EditorServices.NavigableContainer, Int32, Int32)
FSharp.Compiler.EditorServices.NavigableItemKind+Tags: Int32 Constructor
FSharp.Compiler.EditorServices.NavigableItemKind+Tags: Int32 EnumCase
FSharp.Compiler.EditorServices.NavigableItemKind+Tags: Int32 Exception
Expand Down
1 change: 1 addition & 0 deletions tests/FSharp.Compiler.Service.Tests/FSharp.Compiler.Service.Tests.fsproj
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -52,6 +52,7 @@
<Compile Include="ExprTests.fs" />
<Compile Include="CSharpProjectAnalysis.fs" />
<Compile Include="ServiceUntypedParseTests.fs" />
<Compile Include="NavigateToTests.fs" />
<Compile Include="PatternMatchCompilationTests.fs" />
<Compile Include="CompletionTests.fs" />
<Compile Include="ScriptOptionsTests.fs" />
Expand Down
65 changes: 65 additions & 0 deletions tests/FSharp.Compiler.Service.Tests/NavigateToTests.fs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,65 @@
module FSharp.Compiler.Service.Tests.NavigateToTests

open FSharp.Compiler.EditorServices
open FSharp.Compiler.Service.Tests.Common
open FSharp.Compiler.Syntax
open Xunit

let private implementation =
"""
let value = 1
let curried a b = a + b
let tupledAndCurried (a, b) c = a + b + c
let takesUnit () = 1
let generic<'T> (x: 'T) = x

type C<'T, 'U>() =
member _.Method(a: int, b: int) = a + b
member _.Property = 1
static member Static x y = x + y
"""

let private signature =
"""
module M

val curried: int -> int -> int
val takesUnit: unit -> int
val takesNamedUnit: u: unit -> int
val generic<'T> : 'T * 'T -> 'T

type C<'T> =
member Method: a: int * b: int -> int
abstract Abstract: unit -> unit
"""

let private arityOf (parseTree: ParsedInput) name =
let item =
NavigateTo.GetNavigableItems parseTree
|> Array.find (fun item -> item.Name = name)

item.ParameterCount, item.TypeParameterCount

[<Theory>]
[<InlineData("value", 0, 0)>]
[<InlineData("curried", 2, 0)>]
[<InlineData("tupledAndCurried", 3, 0)>]
[<InlineData("takesUnit", 0, 0)>]
[<InlineData("generic", 1, 1)>]
[<InlineData("C", 0, 2)>]
[<InlineData("Method", 2, 0)>]
[<InlineData("Property", 0, 0)>]
[<InlineData("Static", 2, 0)>]
let ``A declaration in an implementation file counts the parameters it compiles to`` (name: string, parameterCount: int, typeParameterCount: int) =
Assert.Equal((parameterCount, typeParameterCount), arityOf (getParseResults implementation) name)

[<Theory>]
[<InlineData("curried", 2, 0)>]
[<InlineData("takesUnit", 0, 0)>]
[<InlineData("takesNamedUnit", 0, 0)>]
[<InlineData("generic", 2, 1)>]
[<InlineData("C", 0, 1)>]
[<InlineData("Method", 2, 0)>]
[<InlineData("Abstract", 0, 0)>]
let ``A declaration in a signature file counts the parameters it compiles to`` (name: string, parameterCount: int, typeParameterCount: int) =
Assert.Equal((parameterCount, typeParameterCount), arityOf (getParseResultsOfSignatureFile signature) name)
Loading