Initial proof of concept

src/fsharp/service/FSharpCheckerResults.fs

@@ -1885,6 +1885,19 @@ type FSharpCheckFileResults
                                 FSharpSymbolUse(scope.TcGlobals, symbolUse.DisplayEnv, symbol, symbolUse.ItemOccurence, symbolUse.Range)
                 })
 
+    member __.GetAllUsesOfAllSymbolsInFileWithinRange(outerRange: range, ?cancellationToken: CancellationToken) = 
+        threadSafeOp 
+            (fun () -> [| |])
+            (fun scope ->
+                let cenv = scope.SymbolEnv
+                [| 
+                    for symbolUseChunk in scope.ScopeSymbolUses.AllUsesOfSymbols do
+                        for symbolUse in symbolUseChunk do
+                            cancellationToken |> Option.iter (fun ct -> ct.ThrowIfCancellationRequested())
+                            if rangeContainsRange outerRange symbolUse.Range && symbolUse.ItemOccurence <> ItemOccurence.RelatedText then
+                                let symbol = FSharpSymbol.Create(cenv, symbolUse.Item)
+                                FSharpSymbolUse(scope.TcGlobals, symbolUse.DisplayEnv, symbol, symbolUse.ItemOccurence, symbolUse.Range) |])
+
     member __.GetUsesOfSymbolInFile(symbol:FSharpSymbol, ?cancellationToken: CancellationToken) = 
         threadSafeOp 
             (fun () -> [| |]) 

src/fsharp/service/FSharpCheckerResults.fsi

@@ -212,6 +212,10 @@ type public FSharpCheckFileResults =
     /// Get all textual usages of all symbols throughout the file
     member GetAllUsesOfAllSymbolsInFile : ?cancellationToken: CancellationToken -> seq<FSharpSymbolUse>
 
+    /// <summary>Get all textual usages of all symbols throughout a typechecked file that fall within a given range.</summary>
+    /// <param name="outerRange">The range in the typechecked document that all symbols must by defined within</param>
+    member GetAllUsesOfAllSymbolsInFileWithinRange : outerRange: range -> Async<FSharpSymbolUse[]>
+
     /// Get the textual usages that resolved to the given symbol throughout the file
     member GetUsesOfSymbolInFile : symbol:FSharpSymbol * ?cancellationToken: CancellationToken -> FSharpSymbolUse[]
 

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

@@ -53,7 +53,6 @@
     <Compile Include="LanguageService\LanguageService.fs" />
     <Compile Include="LanguageService\AssemblyContentProvider.fs" />
     <Compile Include="LanguageService\SymbolHelpers.fs" />
-    <Compile Include="InlineHints\InlineHints.fs" />
     <Compile Include="Classification\ClassificationDefinitions.fs" />
     <Compile Include="Classification\ClassificationService.fs" />
     <Compile Include="Formatting\BraceMatchingService.fs" />
@@ -85,6 +84,7 @@
     <Compile Include="QuickInfo\Navigation.fs" />
     <Compile Include="QuickInfo\Views.fs" />
     <Compile Include="QuickInfo\QuickInfoProvider.fs" />
+    <Compile Include="InlineHints\InlineHints.fs" />
     <Compile Include="Structure\BlockStructureService.fs" />
     <Compile Include="Commands\HelpContextService.fs" />
     <Compile Include="Commands\FsiCommandService.fs" />

vsintegration/src/FSharp.Editor/InlineHints/InlineHints.fs

@@ -1,47 +1,117 @@
 // Copyright (c) Microsoft Corporation.  All Rights Reserved.  See License.txt in the project root for license information.
 namespace Microsoft.VisualStudio.FSharp.Editor
 
-open System.Composition
+open Microsoft.VisualStudio.Shell
+
+open System
 open System.Collections.Immutable
 open System.Threading
+open System.ComponentModel.Composition
 
 open Microsoft.CodeAnalysis
 open Microsoft.CodeAnalysis.Text
 open Microsoft.CodeAnalysis.ExternalAccess.FSharp.InlineHints
 
 open FSharp.Compiler
-open FSharp.Compiler.Range
 open FSharp.Compiler.SourceCodeServices
-open FSharp.Compiler.SyntaxTree
 
 [<Export(typeof<IFSharpInlineHintsService>)>]
-type internal FSharpInlineHintsService [<ImportingConstructor>] (checkerProvider: FSharpCheckerProvider, projectInfoManager: FSharpProjectOptionsManager) =
+type internal FSharpInlineHintsService
+    [<ImportingConstructor>]
+    (
+        checkerProvider: FSharpCheckerProvider,
+        [<Import(typeof<SVsServiceProvider>)>] serviceProvider: IServiceProvider,
+        projectInfoManager: FSharpProjectOptionsManager
+    ) =
 
     static let userOpName = "FSharpInlineHints"
 
     interface IFSharpInlineHintsService with
-        member _.GetInlineHintsAsync(document: Document, _textSpan: TextSpan, cancellationToken: CancellationToken) =
+        member _.GetInlineHintsAsync(document: Document, textSpan: TextSpan, cancellationToken: CancellationToken) =
             asyncMaybe {
-                let! _parsingOptions, projectOptions = projectInfoManager.TryGetOptionsForEditingDocumentOrProject(document, cancellationToken, userOpName)
+                let! textVersion = document.GetTextVersionAsync(cancellationToken)
+                let! parsingOptions, projectOptions = projectInfoManager.TryGetOptionsForEditingDocumentOrProject(document, cancellationToken, userOpName)
                 let! sourceText = document.GetTextAsync(cancellationToken)
-                //let defines = CompilerEnvironment.GetCompilationDefinesForEditing parsingOptions
-                //let _textLine = sourceText.Lines.GetLineFromPosition(textSpan.Start)
-                //let _textLinePos = sourceText.Lines.GetLinePosition(textSpan.Start)
-                //let _fcsTextLineNumber = Line.fromZ textLinePos.Line
-                //let! _symbol = Tokenizer.getSymbolAtPosition(document.Id, sourceText, textSpan.Start, document.FilePath, defines, SymbolLookupKind.Greedy, false, false)
                 let! _parseFileResults, _, checkFileResults = checkerProvider.Checker.ParseAndCheckDocument(document, projectOptions, userOpName)
-                let! symbols = checkFileResults.GetAllUsesOfAllSymbolsInFile() |> liftAsync
-                //let! symbolUse = checkFileResults.GetSymbolUseAtLocation(fcsTextLineNumber, symbol.Ident.idRange.EndColumn, textLine.Text.ToString(), symbol.FullIsland, userOpName=userOpName)
-
-                let hints =
-                    [|
-                        for symbol in symbols do
-                            // let givenRange = RoslynHelpers.TextSpanToFSharpRange
-                            let symbolSpan = RoslynHelpers.FSharpRangeToTextSpan(sourceText, symbol.RangeAlternate)
-                            FSharpInlineHint(TextSpan(symbolSpan.Start, 0), ImmutableArray.Create(TaggedText(TextTags.Text, symbol.Symbol.DisplayName + ":")))
-                    |]
-
-                return hints.ToImmutableArray()
+                let range = RoslynHelpers.TextSpanToFSharpRange(document.FilePath, textSpan, sourceText)
+                let! symbolUses = checkFileResults.GetAllUsesOfAllSymbolsInFileWithinRange(range) |> liftAsync
+
+                let typeHints = ImmutableArray.CreateBuilder()
+
+                // todo - get these at some point I guess
+                // most likely need to work with the parse tree API
+                // since there is no good way to tell if a symbol is a parameter (declared or used)
+                let _parameterHints = ImmutableArray.CreateBuilder()
+
+                for symbolUse in symbolUses do
+                    if symbolUse.IsFromDefinition then
+                        match symbolUse.Symbol with
+                        | :? FSharpMemberOrFunctionOrValue as x when x.IsValue && not x.IsMemberThisValue && not x.IsConstructorThisValue ->
+                            let symbolSpan = RoslynHelpers.FSharpRangeToTextSpan(sourceText, symbolUse.RangeAlternate)
+
+                            // TODO: look for if 'x' is SynExpr.Typed perhaps?
+
+                            // This does not correctly "classify" non-F# types
+                            // TODO deal with that, probably via a new API?
+                            let typeLayout = x.FormatLayout symbolUse.DisplayContext
+
+                            let taggedText = ResizeArray()        
+
+                            Layout.renderL (Layout.taggedTextListR taggedText.Add) typeLayout |> ignore
+
+                            let displayParts = ImmutableArray.CreateBuilder()
+                            displayParts.Add(TaggedText(TextTags.Text, ": "))
+
+                            taggedText
+                            |> Seq.map (fun tt -> RoslynHelpers.roslynTag tt.Tag, tt.Text)
+                            |> Seq.map (fun (tag, text) -> TaggedText(tag, text))
+                            |> Seq.iter (fun tt -> displayParts.Add(tt))
+
+                            // TODO - this is not actually correct
+                            // We need to get QuickInfo for the actual type we pull out, not the value
+                            // This code is correct for parameter name hints though, if that gets done!
+                            let callBack position =
+                                fun _ _ ->
+                                    asyncMaybe {
+                                        let! quickInfo =
+                                            FSharpAsyncQuickInfoSource.ProvideQuickInfo(
+                                                checkerProvider.Checker,
+                                                document.Id,
+                                                sourceText,
+                                                document.FilePath,
+                                                position,
+                                                parsingOptions,
+                                                projectOptions,
+                                                textVersion.GetHashCode(),
+                                                document.FSharpOptions.LanguageServicePerformance)
+
+                                        let documentationBuilder = XmlDocumentation.CreateDocumentationBuilder(serviceProvider.XMLMemberIndexService)
+                                        let mainDesc, docs  = FSharpAsyncQuickInfoSource.BuildSingleQuickInfoItem documentationBuilder quickInfo
+
+                                        let descriptionParts = ImmutableArray.CreateBuilder()
+
+                                        mainDesc
+                                        |> Seq.map (fun tt -> RoslynHelpers.roslynTag tt.Tag, tt.Text)
+                                        |> Seq.map (fun (tag, text) -> TaggedText(tag, text))
+                                        |> Seq.iter (fun tt -> descriptionParts.Add(tt))
+
+                                        docs
+                                        |> Seq.map (fun tt -> RoslynHelpers.roslynTag tt.Tag, tt.Text)
+                                        |> Seq.map (fun (tag, text) -> TaggedText(tag, text))
+                                        |> Seq.iter (fun tt -> descriptionParts.Add(tt))
+
+                                        return (descriptionParts.ToImmutableArray())
+                                    }
+                                    |> Async.map (Option.defaultValue ImmutableArray<_>.Empty)
+                                    |> RoslynHelpers.StartAsyncAsTask(cancellationToken)
+
+                            let getDescriptionAsync position = Func<Document, CancellationToken, _>(callBack position)
+
+                            let hint = FSharpInlineHint(TextSpan(symbolSpan.End, 0), displayParts.ToImmutableArray(), getDescriptionAsync symbolSpan.Start)
+                            typeHints.Add(hint)
+                        | _ -> ()
+
+                return typeHints.ToImmutableArray()
             }
             |> Async.map (Option.defaultValue ImmutableArray<_>.Empty)
-            |> RoslynHelpers.StartAsyncAsTask(cancellationToken)
+            |> RoslynHelpers.StartAsyncAsTask(cancellationToken)