AddExplicitReturnType refactoring

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

@@ -99,6 +99,7 @@
     <Compile Include="Commands\HelpContextService.fs" />
     <Compile Include="Commands\FsiCommandService.fs" />
     <Compile Include="Commands\XmlDocCommandService.fs" />
+    <Compile Include="Refactor\AddReturnType.fs" />
     <Compile Include="Refactor\ChangeTypeofWithNameToNameofExpression.fs" />
     <Compile Include="Refactor\AddExplicitTypeToParameter.fs" />
     <Compile Include="Refactor\ChangeDerefToValueRefactoring.fs" />

vsintegration/src/FSharp.Editor/FSharp.Editor.resx

@@ -353,6 +353,9 @@ Use live (unsaved) buffers for analysis</value>
   <data name="ConvertCSharpUsingToFSharpOpen" xml:space="preserve">
     <value>Convert C# 'using' to F# 'open'</value>
   </data>
+  <data name="AddReturnTypeAnnotation" xml:space="preserve">
+    <value>Add return type annotation</value>
+  </data>
   <data name="RemoveUnnecessaryParentheses" xml:space="preserve">
     <value>Remove unnecessary parentheses</value>
   </data>

vsintegration/src/FSharp.Editor/Refactor/AddReturnType.fs

@@ -0,0 +1,118 @@
+namespace Microsoft.VisualStudio.FSharp.Editor
+
+open System.Composition
+open FSharp.Compiler.CodeAnalysis
+open FSharp.Compiler.Symbols
+open FSharp.Compiler.Text
+
+open Microsoft.CodeAnalysis.Text
+open Microsoft.CodeAnalysis.CodeRefactorings
+open Microsoft.CodeAnalysis.CodeActions
+open CancellableTasks
+
+[<ExportCodeRefactoringProvider(FSharpConstants.FSharpLanguageName, Name = "AddReturnType"); Shared>]
+type internal AddReturnType [<ImportingConstructor>] () =
+    inherit CodeRefactoringProvider()
+
+    static member isValidMethodWithoutTypeAnnotation
+        (symbolUse: FSharpSymbolUse)
+        (parseFileResults: FSharpParseFileResults)
+        (funcOrValue: FSharpMemberOrFunctionOrValue)
+        =
+        let typeAnnotationRange =
+            parseFileResults.TryRangeOfReturnTypeHint(symbolUse.Range.Start, false)
+
+        let res =
+            funcOrValue.CompiledName = funcOrValue.DisplayName
+            && funcOrValue.IsFunction
+            && not (parseFileResults.IsBindingALambdaAtPosition symbolUse.Range.Start)
+            && not (funcOrValue.ReturnParameter.Type.IsUnresolved)
+            && not (parseFileResults.IsTypeAnnotationGivenAtPosition symbolUse.Range.Start)
+            && not typeAnnotationRange.IsNone
+
+        match (res, typeAnnotationRange) with
+        | (true, Some tr) -> Some(funcOrValue, tr)
+        | (_, _) -> None
+
+    static member refactor
+        (context: CodeRefactoringContext)
+        (memberFunc: FSharpMemberOrFunctionOrValue, typeRange: Range, symbolUse: FSharpSymbolUse)
+        =
+        let title = SR.AddReturnTypeAnnotation()
+
+        let getChangedText (sourceText: SourceText) =
+            let returnType = memberFunc.ReturnParameter.Type
+
+            let inferredType =
+                let res = returnType.Format symbolUse.DisplayContext
+
+                if returnType.HasTypeDefinition then
+                    res
+                else
+                    $"({res})".Replace(" ", "")
+
+            let textSpan = RoslynHelpers.FSharpRangeToTextSpan(sourceText, typeRange)
+            let textChange = TextChange(textSpan, $": {inferredType} ")
+            sourceText.WithChanges(textChange)
+
+        let codeActionFunc =
+            cancellableTask {
+                let! cancellationToken = CancellableTask.getCancellationToken ()
+                let! sourceText = context.Document.GetTextAsync(cancellationToken)
+                let changedText = getChangedText sourceText
+
+                let newDocument = context.Document.WithText(changedText)
+                return newDocument
+            }
+
+        let codeAction = CodeAction.Create(title, codeActionFunc, title)
+
+        do context.RegisterRefactoring(codeAction)
+
+    static member ofFSharpMemberOrFunctionOrValue(symbol: FSharpSymbol) =
+        match symbol with
+        | :? FSharpMemberOrFunctionOrValue as v -> Some v
+        | _ -> None
+
+    override _.ComputeRefactoringsAsync context =
+        cancellableTask {
+            let document = context.Document
+            let position = context.Span.Start
+            let! sourceText = document.GetTextAsync()
+            let textLine = sourceText.Lines.GetLineFromPosition position
+            let textLinePos = sourceText.Lines.GetLinePosition position
+            let fcsTextLineNumber = Line.fromZ textLinePos.Line
+
+            let! lexerSymbol =
+                document.TryFindFSharpLexerSymbolAsync(position, SymbolLookupKind.Greedy, false, false, nameof (AddReturnType))
+
+            let! (parseFileResults, checkFileResults) = document.GetFSharpParseAndCheckResultsAsync(nameof (AddReturnType))
+
+            let symbolUseOpt =
+                lexerSymbol
+                |> Option.bind (fun lexer ->
+                    checkFileResults.GetSymbolUseAtLocation(
+                        fcsTextLineNumber,
+                        lexer.Ident.idRange.EndColumn,
+                        textLine.ToString(),
+                        lexer.FullIsland
+                    ))
+
+            let memberFuncOpt =
+                symbolUseOpt
+                |> Option.bind (fun sym -> sym.Symbol |> AddReturnType.ofFSharpMemberOrFunctionOrValue)
+
+            match (symbolUseOpt, memberFuncOpt) with
+            | (Some symbolUse, Some memberFunc) ->
+                let isValidMethod =
+                    memberFunc
+                    |> AddReturnType.isValidMethodWithoutTypeAnnotation symbolUse parseFileResults
+
+                match isValidMethod with
+                | Some(memberFunc, typeRange) -> do AddReturnType.refactor context (memberFunc, typeRange, symbolUse)
+                | None -> ()
+            | _ -> ()
+
+            return ()
+        }
+        |> CancellableTask.startAsTask context.CancellationToken

vsintegration/tests/FSharp.Editor.Tests/FSharp.Editor.Tests.fsproj

@@ -12,6 +12,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+
     <Content Include="xunit.runner.json" CopyToOutputDirectory="PreserveNewest" />
   </ItemGroup>
 
@@ -71,6 +72,8 @@
     <Compile Include="CodeFixes\ConvertCSharpUsingToFSharpOpenTests.fs" />
     <Compile Include="CodeFixes\ReplaceWithSuggestionTests.fs" />
     <Compile Include="CodeFixes\RemoveUnnecessaryParenthesesTests.fs" />
+    <Compile Include="Refactors\RefactorTestFramework.fs" />
+    <Compile Include="Refactors\AddReturnTypeTests.fs" />
     <Compile Include="Hints\HintTestFramework.fs" />
     <Compile Include="Hints\OptionParserTests.fs" />
     <Compile Include="Hints\InlineParameterNameHintTests.fs" />

vsintegration/tests/FSharp.Editor.Tests/Helpers/RoslynHelpers.fs

@@ -304,6 +304,11 @@ type RoslynTestHelpers private () =
         let document = project.Documents |> Seq.exactlyOne
         document
 
+    static member GetLastDocument(solution: Solution) =
+        let project = solution.Projects |> Seq.exactlyOne
+        let document = project.Documents |> Seq.last
+        document
+
     static member CreateSolution(syntheticProject: SyntheticProject) =
 
         let checker = syntheticProject.SaveAndCheck()