Add support for tuples and attributes.

Author: nojaf

ReSharper.FSharp/src/FSharp.Psi.Features/src/LanguageService/FSharpElementFactory.fs

@@ -109,16 +109,22 @@ type FSharpElementFactory(languageService: IFSharpLanguageService, sourceFile: I
         let bindingSignature = moduleMember :?> IBindingSignature
         bindingSignature.ReturnTypeInfo.ReturnType
 
-    let createParameterSignatureTypeUsageForSignature name typeUsage: ITypeUsage =
-        let source = "module V\nval a: b: obj -> obj"
+    let createParameterSignatureTypeUsageForSignature attributes name typeUsage: ITypeUsage =
+        let source = $"module V\nval a: {attributes} b: obj -> obj"
         let moduleMember = getModuleMember source
         let bindingSignature = moduleMember :?> IBindingSignature
         match bindingSignature.ReturnTypeInfo.ReturnType with
         | :? IFunctionTypeUsage as ft ->
             match ft.ArgumentTypeUsage with
             | :? IParameterSignatureTypeUsage as pstu ->
-                pstu.SetIdentifier(name) |> ignore
-                pstu.SetTypeUsage(typeUsage) |> ignore
+                if System.String.IsNullOrWhiteSpace attributes then
+                    pstu.SetIdentifier(name) |> ignore
+                    pstu.SetTypeUsage(typeUsage) |> ignore
+                else
+                    // When attributes are present, SetIdentifier and SetTypeUsage no longer seem to work.
+                    replace pstu.Identifier name
+                    replace pstu.TypeUsage typeUsage
+
                 pstu
             | _ -> failwith "Could not get IParameterSignatureTypeUsage in ArgumentTypeUsage"
         | _ -> failwith "Could not get IFunctionTypeUsage in IBindingSignature.ReturnTypeInfo.ReturnType"
@@ -342,8 +348,8 @@ type FSharpElementFactory(languageService: IFSharpLanguageService, sourceFile: I
         member x.CreateTypeUsageForSignature(typeUsage: string): ITypeUsage =
             createTypeUsageForSignature typeUsage
 
-        member x.CreateParameterSignatureTypeUsage(name: IFSharpIdentifier, typeUsage:ITypeUsage) =
-            createParameterSignatureTypeUsageForSignature name typeUsage
+        member x.CreateParameterSignatureTypeUsage(attributes: string, name: IFSharpIdentifier, typeUsage:ITypeUsage) =
+            createParameterSignatureTypeUsageForSignature attributes name typeUsage
 
         member x.CreateBindingSignature(bindingName: IFSharpPattern, returnType: ITypeUsage) =
             let signature = createBindingSignature ()

ReSharper.FSharp/src/FSharp.Psi.Intentions/src/Intentions/AddFunctionToSignatureFileAction.fs

@@ -12,6 +12,12 @@ open JetBrains.ReSharper.Resources.Shell
 open JetBrains.ReSharper.Plugins.FSharp.Psi.Impl.Tree
 open JetBrains.ReSharper.Psi.Tree
 
+[<RequireQualifiedAccess>]
+type private ParameterNameFromPattern =
+    | NoNameFound
+    | SingleName of name: IFSharpIdentifier * attributes: string
+    | TupleName of ParameterNameFromPattern list
+
 [<ContextAction(Name = "AddFunctionToSignatureFile", Group = "F#", Description = "Add function to signature file")>]
 type AddFunctionToSignatureFileAction(dataProvider: FSharpContextActionDataProvider) =
     inherit FSharpContextActionBase(dataProvider)
@@ -23,11 +29,26 @@ type AddFunctionToSignatureFileAction(dataProvider: FSharpContextActionDataProvi
             |> Option.bind (fun range -> if range.FileName.EndsWith(".fs") then Some valSymbol else None)
         | _ -> None
 
-    let rec tryFindParameterName (p: IFSharpPattern) =
+    let rec tryFindParameterName (isTopLevel: bool) (p: IFSharpPattern) : ParameterNameFromPattern =
         match p.IgnoreInnerParens() with
-        | :? ITypedPat as tp -> tryFindParameterName tp.Pattern
-        | :? ILocalReferencePat as rp -> Some rp.Identifier
-        | _ -> None
+        | :? ITypedPat as tp -> tryFindParameterName isTopLevel tp.Pattern
+        | :? ILocalReferencePat as rp -> ParameterNameFromPattern.SingleName (rp.Identifier, "")
+        | :? IAttribPat as ap ->
+            match tryFindParameterName isTopLevel ap.Pattern with
+            | ParameterNameFromPattern.SingleName(name, _) ->
+                let attributes = Seq.map (fun (al:IAttributeList) -> al.GetText()) ap.AttributeListsEnumerable |> String.concat ""
+                ParameterNameFromPattern.SingleName(name, attributes)
+            | _ ->
+                ParameterNameFromPattern.NoNameFound
+        | :? ITuplePat as tp ->
+            if not isTopLevel then
+                ParameterNameFromPattern.NoNameFound
+            else
+
+            Seq.map (tryFindParameterName false) tp.Patterns
+            |> Seq.toList
+            |> ParameterNameFromPattern.TupleName
+        | _ -> ParameterNameFromPattern.NoNameFound
 
     let implBindingAndDecl =
         let currentFSharpFile = dataProvider.PsiFile
@@ -102,22 +123,34 @@ type AddFunctionToSignatureFileAction(dataProvider: FSharpContextActionDataProvi
                     replace t (factory.WrapParenAroundTypeUsageForSignature(t))
                 | _ -> ()
             else
-                // TODO: take tuples into account.
-                let parameterAtIndex = tryFindParameterName (binding.ParameterPatterns.Item(index))
+                let parameterAtIndex = tryFindParameterName true (binding.ParameterPatterns.Item(index))
 
                 match t, parameterAtIndex with
-                | :? IFunctionTypeUsage as ft, Some parameterName ->
+                | :? IFunctionTypeUsage as ft, ParameterNameFromPattern.NoNameFound ->
+                    visit (index + 1) ft.ReturnTypeUsage
+
+                | :? IFunctionTypeUsage as ft, ParameterNameFromPattern.SingleName (name, attributes) ->
                     match ft.ArgumentTypeUsage with
                     | :? IParameterSignatureTypeUsage as pstu ->
-                        // Update the parameter name if it was found in the implementation file
-                        // calling SetIdentifier on pstu does not add a ':' token.
-                        let namedTypeUsage = factory.CreateParameterSignatureTypeUsage(parameterName, pstu.TypeUsage)
-                        replace ft.ArgumentTypeUsage namedTypeUsage
+                        factory.CreateParameterSignatureTypeUsage(attributes, name, pstu.TypeUsage)
+                        |> replace ft.ArgumentTypeUsage 
                     | _ -> ()
 
                     visit (index + 1) ft.ReturnTypeUsage
-                | :? IFunctionTypeUsage as ft, None ->
-                    visit (index + 1) ft.ReturnTypeUsage
+
+                | :? IFunctionTypeUsage as ft, ParameterNameFromPattern.TupleName multipleParameterNames ->
+                    match ft.ArgumentTypeUsage with
+                    | :? ITupleTypeUsage as tt when tt.Items.Count = multipleParameterNames.Length ->
+                        (multipleParameterNames, tt.Items)
+                        ||> Seq.zip
+                        |> Seq.iter (fun (p,t) ->
+                            match t, p with
+                            | :? IParameterSignatureTypeUsage as pstu,  ParameterNameFromPattern.SingleName (name, attributes) ->
+                                factory.CreateParameterSignatureTypeUsage(attributes, name, pstu.TypeUsage) 
+                                |> replace t
+                            | _ -> ()
+                        )
+                    | _ -> visit (index + 1) ft.ReturnTypeUsage
                 | _ ->
                     ()
 

ReSharper.FSharp/src/FSharp.Psi/src/IFSharpElementFactory.cs

@@ -36,7 +36,7 @@ public interface IFSharpElementFactory
     ITypeUsage CreateTypeUsage(string typeUsage);
 
     ITypeUsage CreateTypeUsageForSignature(string typeUsage);
-    ITypeUsage CreateParameterSignatureTypeUsage(IFSharpIdentifier name, ITypeUsage typeUsage);
+    ITypeUsage CreateParameterSignatureTypeUsage(string attributes, IFSharpIdentifier name, ITypeUsage typeUsage);
     IBindingSignature CreateBindingSignature(IFSharpPattern bindingName, ITypeUsage returnType);
     ITypeUsage WrapParenAroundTypeUsageForSignature(ITypeUsage typeUsage);
 

ReSharper.FSharp/test/src/FSharp.Intentions.Tests/src/Intentions/AddFunctionToSignatureFileActionTest.fs

@@ -22,3 +22,7 @@ type AddFunctionToSignatureFileActionTest() =
     [<Test>] member x.``Simple Binding - 02`` () = x.DoNamedTestWithSignature()
     [<Test>] member x.``Simple Binding - 03`` () = x.DoNamedTestWithSignature()
     [<Test>] member x.``Simple Binding - 04`` () = x.DoNamedTestWithSignature()
+    [<Test>] member x.``Tuple parameter - 01`` () = x.DoNamedTestWithSignature()
+    [<Test>] member x.``Tuple parameter - 02`` () = x.DoNamedTestWithSignature()
+    [<Test>] member x.``Attribute in parameter - 01`` () = x.DoNamedTestWithSignature()
+    [<Test>] member x.``Attribute in parameter - 02`` () = x.DoNamedTestWithSignature()