A code refactoring for explicit return type annotation

[psfinaki]

Given the code
let add x y = x + y

Create a refactoring that would suggesting rewriting it to
let add x y : int = x + y

I think this should be easy. We have:

1. Machinery to create refactorings
2. Methods to extract return type info - used in return type hints

Originally posted by @psfinaki in #10421 (comment)

[0101]

Possibly also for the parameters.

[SebastianAtWork]

Hi, I currently have a bit of free time and would like to get startet contributing to fsharp. If its ok with you guys, I would start looking into this. Any more pointers for a newcomer to this repo are of course appreciated :)

[psfinaki]

Hello there, @SebastianAtWork, you are absolutely very welcome to help with this :)

Here are a few tips for you:

• We already have a couple of refactorings here, take a look at what's going on there. Ultimately they all inherit from the dedicated VS class (in this case CodeRefactoringProvider) and override it's members.
• This refactoring we have is actually very close as it's adding type to the parameters. It's getting type information from the document and adds it whenever applicable.
• Unfortunately, we don't have a proper testing framework for this yet (as opposed to hints or code fixes). This means we'll need to test this manually for now. Here are the guidelines how to do that.

If you have any questions, feel free to ask. This should be doable and will be very useful to have!

[SebastianAtWork]

@psfinaki Already 2 weeks wow, time sure flies fast. Quick Update: I looked into how refactorings (and for some reason codefixes) work. I have a little bit of trouble finding resources for the different lexing and parsing symbols. Here is my current version that sill needs a few things:

 [<ExportCodeRefactoringProvider(FSharpConstants.FSharpLanguageName, Name = "AddExplicitReturnType"); Shared>]
type internal AddExplicitReturnType [<ImportingConstructor>] () =
    inherit CodeRefactoringProvider()

    override _.ComputeRefactoringsAsync context =
        asyncMaybe {
            let document = context.Document
            let position = context.Span.Start
            let! sourceText = document.GetTextAsync() |> liftTaskAsync
            let textLine = sourceText.Lines.GetLineFromPosition position
            let textLinePos = sourceText.Lines.GetLinePosition position
            let fcsTextLineNumber = Line.fromZ textLinePos.Line

            let! ct = Async.CancellationToken |> liftAsync

            let! lexerSymbol =
                document.TryFindFSharpLexerSymbolAsync(position, SymbolLookupKind.Greedy, false, false, nameof (AddExplicitReturnType))

            let! parseFileResults, checkFileResults =
                document.GetFSharpParseAndCheckResultsAsync(nameof (AddExplicitReturnType))
                |> CancellableTask.start ct
                |> Async.AwaitTask
                |> liftAsync

            let! symbolUse =
                checkFileResults.GetSymbolUseAtLocation(
                    fcsTextLineNumber,
                    lexerSymbol.Ident.idRange.EndColumn,
                    textLine.ToString(),
                    lexerSymbol.FullIsland
                )

            let isValidMethodWithoutTypeAnnotation (funcOrValue: FSharpMemberOrFunctionOrValue) (symbolUse: FSharpSymbolUse) =
                let isLambdaIfFunction =
                    funcOrValue.IsFunction
                    && parseFileResults.IsBindingALambdaAtPosition symbolUse.Range.Start

                (not funcOrValue.IsValue || not isLambdaIfFunction)
                && not (funcOrValue.ReturnParameter.Type.IsUnresolved)
                && not (parseFileResults.IsTypeAnnotationGivenAtPosition symbolUse.Range.Start)

            match symbolUse.Symbol with
            | :? FSharpMemberOrFunctionOrValue as v when isValidMethodWithoutTypeAnnotation v symbolUse ->
                let typeString = v.FullType.FormatWithConstraints symbolUse.DisplayContext
                let title = SR.AddExplicitReturnTypeAnnotation()

                let! symbolSpan = RoslynHelpers.TryFSharpRangeToTextSpan(sourceText, symbolUse.Range)
                let test = "Hi"

                let getChangedText (sourceText: SourceText) =
                    let debugInfo = $"{sourceText} : {typeString} : {symbolSpan} {test}"
                    debugInfo
                    let sub = sourceText.ToString(symbolSpan)

                    let newSub =
                        sub.Replace("=", $":{v.ReturnParameter.Type.TypeDefinition.DisplayName}=")

                    sourceText.Replace(symbolSpan, newSub)

                let codeAction =
                    CodeAction.Create(
                        title,
                        (fun (cancellationToken: CancellationToken) ->
                            async {
                                let! sourceText = context.Document.GetTextAsync(cancellationToken) |> Async.AwaitTask
                                return context.Document.WithText(getChangedText sourceText)
                            }
                            |> RoslynHelpers.StartAsyncAsTask(cancellationToken)),
                        title
                    )

                context.RegisterRefactoring(codeAction)
            | _ -> ()
        }
        |> Async.Ignore
        |> RoslynHelpers.StartAsyncUnitAsTask(context.CancellationToken)

1. isValidMethodWithoutTypeAnnotation should represent the condition for the availability of this refactoring. Am I thinking correctly/ am I missing something?
2. symbolUse currently only gives methe position of the Identifier. How can I find the = Sign Position (I assume thats where I have to add return types?)

[SebastianAtWork]

I think i still have trouble setting up vs2022 with fsharp XD Been switching between editors lately and its always something else that bugs me

[vzarytovskii]

@psfinaki Already 2 weeks wow, time sure flies fast. Quick Update: I looked into how refactorings (and for some reason codefixes) work. I have a little bit of trouble finding resources for the different lexing and parsing symbols. Here is my current version that sill needs a few things:

 [<ExportCodeRefactoringProvider(FSharpConstants.FSharpLanguageName, Name = "AddExplicitReturnType"); Shared>]

type internal AddExplicitReturnType [<ImportingConstructor>] () =

    inherit CodeRefactoringProvider()



    override _.ComputeRefactoringsAsync context =

        asyncMaybe {

            let document = context.Document

            let position = context.Span.Start

            let! sourceText = document.GetTextAsync() |> liftTaskAsync

            let textLine = sourceText.Lines.GetLineFromPosition position

            let textLinePos = sourceText.Lines.GetLinePosition position

            let fcsTextLineNumber = Line.fromZ textLinePos.Line



            let! ct = Async.CancellationToken |> liftAsync



            let! lexerSymbol =

                document.TryFindFSharpLexerSymbolAsync(position, SymbolLookupKind.Greedy, false, false, nameof (AddExplicitReturnType))



            let! parseFileResults, checkFileResults =

                document.GetFSharpParseAndCheckResultsAsync(nameof (AddExplicitReturnType))

                |> CancellableTask.start ct

                |> Async.AwaitTask

                |> liftAsync



            let! symbolUse =

                checkFileResults.GetSymbolUseAtLocation(

                    fcsTextLineNumber,

                    lexerSymbol.Ident.idRange.EndColumn,

                    textLine.ToString(),

                    lexerSymbol.FullIsland

                )



            let isValidMethodWithoutTypeAnnotation (funcOrValue: FSharpMemberOrFunctionOrValue) (symbolUse: FSharpSymbolUse) =

                let isLambdaIfFunction =

                    funcOrValue.IsFunction

                    && parseFileResults.IsBindingALambdaAtPosition symbolUse.Range.Start



                (not funcOrValue.IsValue || not isLambdaIfFunction)

                && not (funcOrValue.ReturnParameter.Type.IsUnresolved)

                && not (parseFileResults.IsTypeAnnotationGivenAtPosition symbolUse.Range.Start)



            match symbolUse.Symbol with

            | :? FSharpMemberOrFunctionOrValue as v when isValidMethodWithoutTypeAnnotation v symbolUse ->

                let typeString = v.FullType.FormatWithConstraints symbolUse.DisplayContext

                let title = SR.AddExplicitReturnTypeAnnotation()



                let! symbolSpan = RoslynHelpers.TryFSharpRangeToTextSpan(sourceText, symbolUse.Range)

                let test = "Hi"



                let getChangedText (sourceText: SourceText) =

                    let debugInfo = $"{sourceText} : {typeString} : {symbolSpan} {test}"

                    debugInfo

                    let sub = sourceText.ToString(symbolSpan)



                    let newSub =

                        sub.Replace("=", $":{v.ReturnParameter.Type.TypeDefinition.DisplayName}=")



                    sourceText.Replace(symbolSpan, newSub)



                let codeAction =

                    CodeAction.Create(

                        title,

                        (fun (cancellationToken: CancellationToken) ->

                            async {

                                let! sourceText = context.Document.GetTextAsync(cancellationToken) |> Async.AwaitTask

                                return context.Document.WithText(getChangedText sourceText)

                            }

                            |> RoslynHelpers.StartAsyncAsTask(cancellationToken)),

                        title

                    )



                context.RegisterRefactoring(codeAction)

            | _ -> ()

        }

        |> Async.Ignore

        |> RoslynHelpers.StartAsyncUnitAsTask(context.CancellationToken)

1. isValidMethodWithoutTypeAnnotation should represent the condition for the availability of this refactoring. Am I thinking correctly/ am I missing something?

2. symbolUse currently only gives methe position of the Identifier. How can I find the = Sign Position (I assume thats where I have to add return types?)

Since it still ignores result, and runs as a non-generic task, asyncMaybe is not necessary, cancellableTask should be used instead.