Inline parameter name hints for F#

vsintegration/src/FSharp.Editor/FSharp.Editor.fsproj

@@ -126,8 +126,12 @@
     <Compile Include="Build\SetGlobalPropertiesForSdkProjects.fs" />
     <Compile Include="AutomaticCompletion\BraceCompletionSessionProvider.fsi" />
     <Compile Include="AutomaticCompletion\BraceCompletionSessionProvider.fs" />
+    <Compile Include="Hints\Hints.fs" />
+    <Compile Include="Hints\InlineTypeHints.fs" />
+    <Compile Include="Hints\InlineParameterNameHints.fs" />
     <Compile Include="Hints\HintService.fs" />
     <Compile Include="Hints\NativeToRoslynHintConverter.fs" />
+    <Compile Include="Hints\OptionParser.fs" />
     <Compile Include="Hints\RoslynAdapter.fs" />
     <Compile Include="Lens\LensDisplayService.fs" />
     <Compile Include="Lens\LensService.fs" />

vsintegration/src/FSharp.Editor/Hints/HintService.fs

@@ -6,64 +6,28 @@ open Microsoft.CodeAnalysis
 open Microsoft.VisualStudio.FSharp.Editor
 open FSharp.Compiler.CodeAnalysis
 open FSharp.Compiler.Symbols
-open FSharp.Compiler.Text
+open Hints
 
 module HintService =
-
-    // Relatively convenient for testing
-    type NativeHint = {
-        Range: range
-        Parts: TaggedText list
-    }
-
-    let private isValidForHint 
-        (parseFileResults: FSharpParseFileResults) 
-        (symbol: FSharpMemberOrFunctionOrValue)
-        (symbolUse: FSharpSymbolUse) =
-
-        let isNotAnnotatedManually = 
-            not (parseFileResults.IsTypeAnnotationGivenAtPosition symbolUse.Range.Start)
-
-        let isNotAfterDot = 
-            symbolUse.IsFromDefinition 
-            && not symbol.IsMemberThisValue
-
-        let isNotTypeAlias = 
-            not symbol.IsConstructorThisValue
-
-        symbol.IsValue // we'll be adding other stuff gradually here
-        && isNotAnnotatedManually
-        && isNotAfterDot
-        && isNotTypeAlias
-
-    let private getHintParts
-        (symbol: FSharpMemberOrFunctionOrValue) 
-        (symbolUse: FSharpSymbolUse) =
-
-        match symbol.GetReturnTypeLayout symbolUse.DisplayContext with
-        | Some typeInfo -> 
-            let colon = TaggedText(TextTag.Text, ": ")
-            colon :: (typeInfo |> Array.toList)
-
-        // not sure when this can happen but better safe than sorry
-        | None -> 
-            []
-
-    let private getHintsForSymbol parseResults (symbolUse: FSharpSymbolUse) =
+    let private getHintsForSymbol parseResults hintKinds (symbolUse: FSharpSymbolUse) =
         match symbolUse.Symbol with
-        | :? FSharpMemberOrFunctionOrValue as mfvSymbol 
-          when isValidForHint parseResults mfvSymbol symbolUse ->
+        | :? FSharpMemberOrFunctionOrValue as symbol 
+          when hintKinds |> Set.contains HintKind.TypeHint 
+            && InlineTypeHints.isValidForHint parseResults symbol symbolUse ->
 
-            [ {
-                Range = symbolUse.Range
-                Parts = getHintParts mfvSymbol symbolUse
-            } ]
+            InlineTypeHints.getHints symbol symbolUse
 
+        | :? FSharpMemberOrFunctionOrValue as symbol
+          when hintKinds |> Set.contains HintKind.ParameterNameHint 
+            && InlineParameterNameHints.isValidForHint symbol ->
+
+            InlineParameterNameHints.getHints parseResults symbol symbolUse
+
         // we'll be adding other stuff gradually here
         | _ -> 
             []
 
-    let getHintsForDocument (document: Document) userOpName cancellationToken = 
+    let getHintsForDocument (document: Document) hintKinds userOpName cancellationToken = 
         async {
             if isSignatureFile document.FilePath
             then 
@@ -75,5 +39,5 @@ module HintService =
                 return 
                     checkResults.GetAllUsesOfAllSymbolsInFile cancellationToken
                     |> Seq.toList
-                    |> List.collect (getHintsForSymbol parseResults)
+                    |> List.collect (getHintsForSymbol parseResults hintKinds)
         }

vsintegration/src/FSharp.Editor/Hints/Hints.fs

@@ -0,0 +1,18 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+namespace Microsoft.VisualStudio.FSharp.Editor.Hints
+
+open FSharp.Compiler.Text
+
+module Hints =
+
+    type HintKind = 
+        | TypeHint
+        | ParameterNameHint
+
+    // Relatively convenient for testing
+    type NativeHint = {
+        Kind: HintKind
+        Range: range
+        Parts: TaggedText list
+    }

vsintegration/src/FSharp.Editor/Hints/InlineParameterNameHints.fs

@@ -0,0 +1,49 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+namespace Microsoft.VisualStudio.FSharp.Editor.Hints
+
+open Microsoft.VisualStudio.FSharp.Editor
+open FSharp.Compiler.CodeAnalysis
+open FSharp.Compiler.Symbols
+open FSharp.Compiler.Text
+open Hints
+
+module InlineParameterNameHints =
+
+    let private getHint (range: range, parameter: FSharpParameter) =
+        {
+            Kind = HintKind.ParameterNameHint
+            Range = range.StartRange
+            Parts = [ TaggedText(TextTag.Text, $"{parameter.DisplayName} = ") ]
+        }
+
+    let private doesParameterNameExist (parameter: FSharpParameter) = 
+        parameter.DisplayName <> ""
+
+    let isValidForHint (symbol: FSharpMemberOrFunctionOrValue) =
+        // is there a better way?
+        let isNotBuiltInOperator = 
+            symbol.DeclaringEntity 
+            |> Option.exists (fun entity -> entity.CompiledName <> "Operators")
+
+        symbol.IsFunction
+        && isNotBuiltInOperator // arguably, hints for those would be rather useless
+
+    let getHints 
+        (parseResults: FSharpParseFileResults) 
+        (symbol: FSharpMemberOrFunctionOrValue) 
+        (symbolUse: FSharpSymbolUse) =
+
+        let parameters = symbol.CurriedParameterGroups |> Seq.concat
+        let ranges = parseResults.GetAllArgumentsForFunctionApplicationAtPosition symbolUse.Range.Start
+
+        match ranges with
+        | Some ranges -> 
+            parameters
+            |> Seq.zip ranges
+            |> Seq.where (snd >> doesParameterNameExist)
+            |> Seq.map getHint
+            |> Seq.toList
+
+        // this is the case at least for custom operators
+        | None -> []

vsintegration/src/FSharp.Editor/Hints/InlineTypeHints.fs

@@ -0,0 +1,54 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+namespace Microsoft.VisualStudio.FSharp.Editor.Hints
+
+open Microsoft.VisualStudio.FSharp.Editor
+open FSharp.Compiler.CodeAnalysis
+open FSharp.Compiler.Symbols
+open FSharp.Compiler.Text
+open Hints
+
+module InlineTypeHints =
+
+    let private getHintParts
+        (symbol: FSharpMemberOrFunctionOrValue) 
+        (symbolUse: FSharpSymbolUse) =
+
+        match symbol.GetReturnTypeLayout symbolUse.DisplayContext with
+        | Some typeInfo -> 
+            let colon = TaggedText(TextTag.Text, ": ")
+            colon :: (typeInfo |> Array.toList)
+
+        // not sure when this can happen
+        | None -> 
+            []
+
+    let private getHint symbol (symbolUse: FSharpSymbolUse) =
+        {
+            Kind = HintKind.TypeHint
+            Range = symbolUse.Range.EndRange
+            Parts = getHintParts symbol symbolUse
+        }
+
+    let isValidForHint 
+        (parseFileResults: FSharpParseFileResults) 
+        (symbol: FSharpMemberOrFunctionOrValue)
+        (symbolUse: FSharpSymbolUse) =
+
+        let isNotAnnotatedManually = 
+            not (parseFileResults.IsTypeAnnotationGivenAtPosition symbolUse.Range.Start)
+
+        let isNotAfterDot = 
+            symbolUse.IsFromDefinition 
+            && not symbol.IsMemberThisValue
+
+        let isNotTypeAlias = 
+            not symbol.IsConstructorThisValue
+
+        symbol.IsValue // we'll be adding other stuff gradually here
+        && isNotAnnotatedManually
+        && isNotAfterDot
+        && isNotTypeAlias
+
+    let getHints symbol symbolUse = 
+        [ getHint symbol symbolUse ]

vsintegration/src/FSharp.Editor/Hints/NativeToRoslynHintConverter.fs

@@ -7,7 +7,7 @@ open Microsoft.CodeAnalysis.Text
 open Microsoft.CodeAnalysis.ExternalAccess.FSharp.InlineHints
 open Microsoft.VisualStudio.FSharp.Editor
 open FSharp.Compiler.Text
-open HintService
+open Hints
 
 module NativeToRoslynHintConverter =
 

vsintegration/src/FSharp.Editor/Hints/OptionParser.fs

@@ -0,0 +1,16 @@
+// Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
+
+namespace Microsoft.VisualStudio.FSharp.Editor.Hints
+
+open Microsoft.VisualStudio.FSharp.Editor
+open Hints
+
+module OptionParser =
+
+    let getHintKinds options =
+        Set 
+            [ if options.IsInlineTypeHintsEnabled then
+                 HintKind.TypeHint
+
+              if options.IsInlineParameterNameHintsEnabled then
+                 HintKind.ParameterNameHint ]

vsintegration/src/FSharp.Editor/Hints/RoslynAdapter.fs

@@ -22,17 +22,19 @@ type internal RoslynAdapter
     interface IFSharpInlineHintsService with
         member _.GetInlineHintsAsync(document, _, cancellationToken) =
             async {
-                if not settings.Advanced.IsInlineHintsEnabled 
-                then return ImmutableArray.Empty
-
-                else
-                    let! sourceText = document.GetTextAsync cancellationToken |> Async.AwaitTask
-                    let! nativeHints = 
-                        HintService.getHintsForDocument document userOpName cancellationToken
+                let! sourceText = document.GetTextAsync cancellationToken |> Async.AwaitTask
+                let hintKinds = OptionParser.getHintKinds settings.Advanced
+
+                let! nativeHints =
+                    HintService.getHintsForDocument 
+                        document 
+                        hintKinds
+                        userOpName 
+                        cancellationToken
 
-                    let roslynHints = 
-                        nativeHints 
-                        |> Seq.map (NativeToRoslynHintConverter.convert sourceText)
+                let roslynHints = 
+                    nativeHints 
+                    |> Seq.map (NativeToRoslynHintConverter.convert sourceText)
 
-                    return roslynHints.ToImmutableArray()
+                return roslynHints.ToImmutableArray()
             } |> RoslynHelpers.StartAsyncAsTask cancellationToken

vsintegration/src/FSharp.Editor/Options/EditorOptions.fs

@@ -86,11 +86,13 @@ type LensOptions =
 type AdvancedOptions =
     { IsBlockStructureEnabled: bool
       IsOutliningEnabled: bool
-      IsInlineHintsEnabled: bool }
+      IsInlineTypeHintsEnabled: bool
+      IsInlineParameterNameHintsEnabled: bool }
     static member Default =
       { IsBlockStructureEnabled = true
         IsOutliningEnabled = true
-        IsInlineHintsEnabled = false }
+        IsInlineTypeHintsEnabled = false 
+        IsInlineParameterNameHintsEnabled = false }
 
 [<CLIMutable>]
 type FormattingOptions =

vsintegration/src/FSharp.UIResources/AdvancedOptionsControl.xaml

@@ -25,8 +25,12 @@
                               Content="{x:Static local:Strings.Show_Outlining}"/>
                 </GroupBox>
                 <GroupBox Header="{x:Static local:Strings.Inline_Hints}">
-                    <CheckBox x:Name="toggleInlineHints" IsChecked="{Binding IsInlineHintsEnabled}"
-                              Content="{x:Static local:Strings.Show_Inline_Hints}"/>
+                    <StackPanel>
+                        <CheckBox x:Name="toggleInlineTypeHints" IsChecked="{Binding IsInlineTypeHintsEnabled}"
+                                  Content="{x:Static local:Strings.Show_Inline_Type_Hints}"/>
+                        <CheckBox x:Name="toggleParameterNameHints" IsChecked="{Binding IsInlineParameterNameHintsEnabled}"
+                                  Content="{x:Static local:Strings.Show_Inline_Parameter_Name_Hints}"/>
+                    </StackPanel>
                 </GroupBox>
             </StackPanel>
         </ScrollViewer>

vsintegration/src/FSharp.UIResources/Strings.resx

@@ -192,7 +192,7 @@
   <data name="Inline_Hints" xml:space="preserve">
     <value>Inline Hints</value>
   </data>
-  <data name="Show_Inline_Hints" xml:space="preserve">
+  <data name="Show_Inline_Type_Hints" xml:space="preserve">
     <value>Display inline type hints (experimental)</value>
   </data>
   <data name="Time_until_stale_completion" xml:space="preserve">
@@ -243,4 +243,7 @@
   <data name="Enable_Parallel_Reference_Resolution" xml:space="preserve">
     <value>Enable parallel reference resolution</value>
   </data>
+  <data name="Show_Inline_Parameter_Name_Hints" xml:space="preserve">
+    <value>Display inline parameter name hints (experimental)</value>
+  </data>
 </root>

vsintegration/src/FSharp.UIResources/xlf/Strings.cs.xlf

@@ -82,7 +82,12 @@
         <target state="new">Parallelization (requires restart)</target>
         <note />
       </trans-unit>
-      <trans-unit id="Show_Inline_Hints">
+      <trans-unit id="Show_Inline_Parameter_Name_Hints">
+        <source>Display inline parameter name hints (experimental)</source>
+        <target state="new">Display inline parameter name hints (experimental)</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Show_Inline_Type_Hints">
         <source>Display inline type hints (experimental)</source>
         <target state="new">Display inline type hints (experimental)</target>
         <note />

vsintegration/src/FSharp.UIResources/xlf/Strings.de.xlf

@@ -82,7 +82,12 @@
         <target state="new">Parallelization (requires restart)</target>
         <note />
       </trans-unit>
-      <trans-unit id="Show_Inline_Hints">
+      <trans-unit id="Show_Inline_Parameter_Name_Hints">
+        <source>Display inline parameter name hints (experimental)</source>
+        <target state="new">Display inline parameter name hints (experimental)</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="Show_Inline_Type_Hints">
         <source>Display inline type hints (experimental)</source>
         <target state="new">Display inline type hints (experimental)</target>
         <note />