Revisit long function definitions (#947)

* Revert default style to Microsoft style guide.

* Add setting for G-Research long function definition style.

* Added test for recursive function.

* Correct position of equal sign according to the Microsoft Style guide.

* Corrected typo

Author: nojaf

src/Fantomas.Tests/FunctionDefinitionTests.fs

@@ -384,11 +384,9 @@ let fold (funcs : ResultFunc<'Input, 'Output, 'TError> seq) (input : 'Input) : R
             MaxInfixOperatorExpression = 70 })
     |> prepend newline
     |> should equal """
-let fold
-    (funcs : ResultFunc<'Input, 'Output, 'TError> seq)
-    (input : 'Input)
-    : Result<'Output list, 'TError list>
-    =
+let fold (funcs : ResultFunc<'Input, 'Output, 'TError> seq)
+         (input : 'Input)
+         : Result<'Output list, 'TError list> =
     let mutable anyErrors = false
     let mutable collectedOutputs = []
     let mutable collectedErrors = []
@@ -430,10 +428,9 @@ let ``internal keyword included in function signature length check`` () =
 """  ({ config with MaxLineLength = 90; SpaceBeforeColon = true })
     |> prepend newline
     |> should equal """
-let internal UpdateStrongNaming
-    (assembly : AssemblyDefinition)
-    (key : StrongNameKeyPair option)
-    =
+let internal UpdateStrongNaming (assembly : AssemblyDefinition)
+                                (key : StrongNameKeyPair option)
+                                =
     assembly.Name
 
 let UpdateStrongNamingX (assembly : AssemblyDefinition) (key : StrongNameKeyPair option) =
@@ -469,10 +466,9 @@ module FormatCode =
         CodeFormatter.FormatDocumentAsync("tmp.fsx", source, config, options, checker)
 
     [<FunctionName("FormatCode")>]
-    let run
-        ([<HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = "{*any}")>] req: HttpRequest)
-        (log: ILogger)
-        =
+    let run ([<HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = "{*any}")>] req: HttpRequest)
+            (log: ILogger)
+            =
         Http.main CodeFormatter.GetVersion format FormatConfig.FormatConfig.Default log req
 """
 
@@ -505,11 +501,9 @@ module FormatCode =
         CodeFormatter.FormatDocumentAsync("tmp.fsx", source, config, options, checker)
 
     [<FunctionName("FormatCode")>]
-    let run
-        ([<HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = "{*any}")>] req: HttpRequest)
-        (log: ILogger)
-        : HttpResponse
-        =
+    let run ([<HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = "{*any}")>] req: HttpRequest)
+            (log: ILogger)
+            : HttpResponse =
         Http.main CodeFormatter.GetVersion format FormatConfig.FormatConfig.Default log req
 """
 
@@ -526,14 +520,13 @@ let private addTaskToScheduler (scheduler : IScheduler) taskName taskCron prio (
 """  ({ config with MaxLineLength = 100 })
     |> prepend newline
     |> should equal """
-let private addTaskToScheduler
-    (scheduler: IScheduler)
-    taskName
-    taskCron
-    prio
-    (task: unit -> unit)
-    groupName
-    =
+let private addTaskToScheduler (scheduler: IScheduler)
+                               taskName
+                               taskCron
+                               prio
+                               (task: unit -> unit)
+                               groupName
+                               =
     let mutable jobDataMap = JobDataMap()
     jobDataMap.["task"] <- task
 
@@ -551,11 +544,9 @@ let ``long function signature should align with equal sign, 883`` () =
 """  { config with IndentSize = 2; SpaceBeforeColon = true }
     |> prepend newline
     |> should equal """
-let readModel
-  (updateState : 'State -> EventEnvelope<'Event> list -> 'State)
-  (initState : 'State)
-  : ReadModel<'Event, 'State>
-  =
+let readModel (updateState : 'State -> EventEnvelope<'Event> list -> 'State)
+              (initState : 'State)
+              : ReadModel<'Event, 'State> =
   ()
 """
 
@@ -566,9 +557,105 @@ let ``long function signature should align with equal sign, no return type`` ()
 """  { config with IndentSize = 2; SpaceBeforeColon = true; MaxLineLength = 80 }
     |> prepend newline
     |> should equal """
+let readModel (updateState : 'State -> EventEnvelope<'Event> list -> 'State)
+              (initState : 'State)
+              =
+  ()
+"""
+
+[<Test>]
+let ``long function signature with single tuple parameter and no return type`` () =
+    formatSourceString false """
+let fold (funcs: ResultFunc<'Input, 'Output, 'TError> seq, input: 'Input, input2: 'Input, input3: 'Input) =
+    ()
+"""  { config with MaxLineLength = 90 }
+    |> prepend newline
+    |> should equal """
+let fold (funcs: ResultFunc<'Input, 'Output, 'TError> seq,
+          input: 'Input,
+          input2: 'Input,
+          input3: 'Input) =
+    ()
+"""
+
+[<Test>]
+let ``long function signature with single tuple parameter and return type`` () =
+    formatSourceString false """
+let fold (funcs: ResultFunc<'Input, 'Output, 'TError> seq, input: 'Input, input2: 'Input, input3: 'Input) : Result<'Output list, 'TError list> =
+    ()
+"""  { config with MaxLineLength = 90 }
+    |> prepend newline
+    |> should equal """
+let fold (funcs: ResultFunc<'Input, 'Output, 'TError> seq,
+          input: 'Input,
+          input2: 'Input,
+          input3: 'Input)
+         : Result<'Output list, 'TError list> =
+    ()
+"""
+
+[<Test>]
+let ``align long function signature to indentation without return type `` () =
+    formatSourceString false """
+let fold (funcs: ResultFunc<'Input, 'Output, 'TError> seq) (input: 'Input) (input2: 'Input) (input3: 'Input) = ()
+"""  { config with MaxLineLength = 60; AlignFunctionSignatureToIndentation  = true }
+    |> prepend newline
+    |> should equal """
+let fold
+    (funcs: ResultFunc<'Input, 'Output, 'TError> seq)
+    (input: 'Input)
+    (input2: 'Input)
+    (input3: 'Input)
+    =
+    ()
+"""
+
+[<Test>]
+let ``align long function signature to indentation with return type`` () =
+    formatSourceString false """let readModel (updateState : 'State -> EventEnvelope<'Event> list -> 'State) (initState : 'State) : ReadModel<'Event, 'State> =
+    ()
+"""  { config with IndentSize = 2; SpaceBeforeColon = true; AlignFunctionSignatureToIndentation = true }
+    |> prepend newline
+    |> should equal """
 let readModel
   (updateState : 'State -> EventEnvelope<'Event> list -> 'State)
   (initState : 'State)
+  : ReadModel<'Event, 'State>
   =
   ()
-"""
+"""
+
+[<Test>]
+let ``align long function signature to indentation that are recursive`` () =
+    formatSourceString false """
+let rec run ([<HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = "{*any}")>] req: HttpRequest) (log: ILogger) : HttpResponse =
+        logAnalyticsForRequest log req
+        Http.main CodeFormatter.GetVersion format FormatConfig.FormatConfig.Default log req
+
+and logAnalyticsForRequest (log:ILogger) (httpRequest: HttpRequest) =
+    log.Info (sprintf "Meh: %A" httpRequest)
+"""  { config with MaxLineLength = 60; AlignFunctionSignatureToIndentation = true }
+    |> prepend newline
+    |> should equal """
+let rec run
+    ([<HttpTrigger(AuthorizationLevel.Anonymous,
+                   "get",
+                   "post",
+                   Route = "{*any}")>] req: HttpRequest)
+    (log: ILogger)
+    : HttpResponse
+    =
+    logAnalyticsForRequest log req
+    Http.main
+        CodeFormatter.GetVersion
+        format
+        FormatConfig.FormatConfig.Default
+        log
+        req
+
+and logAnalyticsForRequest
+    (log: ILogger)
+    (httpRequest: HttpRequest)
+    =
+    log.Info(sprintf "Meh: %A" httpRequest)
+"""

src/Fantomas.Tests/LetBindingTests.fs

@@ -341,12 +341,32 @@ let ``line comment before return type info should indent before colon, 565`` ()
     |> should equal """
 module Bar =
     let f a
-        // foo
-        : int
-        =
+          // foo
+          : int =
         0
 """
 
+[<Test>]
+let ``line comment before return type with AlignFunctionSignatureToIndentation`` () =
+    formatSourceString false """
+  let functionName a b c
+    // foo
+    : int
+    =
+    0
+"""  { config with AlignFunctionSignatureToIndentation = true }
+    |> prepend newline
+    |> should equal """
+let functionName
+    a
+    b
+    c
+    // foo
+    : int
+    =
+    0
+"""
+
 [<Test>]
 let ``has symbol in signature requires paren, 564`` () =
     formatSourceString false """module Bar =
@@ -510,12 +530,11 @@ let ``handle hash directives before equals, 728`` () =
         ()
 
     """ config
-    |> should equal """let Baz
-    (firstParam: string)
+    |> should equal """let Baz (firstParam: string)
 #if DEBUG
-    (_: int)
+        (_: int)
 #else
-    (secndParam: int)
+        (secndParam: int)
 #endif
     =
     ()
@@ -535,12 +554,11 @@ let ``multiple empty lines between equals and expression`` () =
         ()
 
     """ config
-    |> should equal """let Baz
-    (firstParam: string)
+    |> should equal """let Baz (firstParam: string)
 #if DEBUG
-    (_: int)
+        (_: int)
 #else
-    (secndParam: int)
+        (secndParam: int)
 #endif
     =
 

src/Fantomas/CodePrinter.fs

@@ -468,9 +468,15 @@ and genExprSepEqPrependType astContext (pat:SynPat) (e: SynExpr) (valInfo:SynVal
             fun ctx ->
                 let alreadyHasNewline = lastWriteEventIsNewline ctx
                 if alreadyHasNewline then
-                    (rep ctx.Config.IndentSize (!- " ") +> !- "=") ctx
-                else
+                    // Column could be 0 when a hash directive was just written
+                    if ctx.Column = 0 then
+                        (rep ctx.Config.IndentSize (!- " ") +> !- "=") ctx
+                    else
+                        !- "=" ctx
+                elif ctx.Config.AlignFunctionSignatureToIndentation then
                     (indent +> sepNln +> !- "=" +> unindent) ctx
+                else
+                    (sepEq +> sepSpace) ctx
         else
             (sepEq +> sepSpace)
 
@@ -486,10 +492,7 @@ and genExprSepEqPrependType astContext (pat:SynPat) (e: SynExpr) (valInfo:SynVal
 
         let hasLineCommentBeforeColon = TriviaHelpers.``has line comment before`` t.Range ctx.Trivia
 
-        let genCommentBeforeColon ctx =
-            (ifElse hasLineCommentBeforeColon indent sepNone
-             +> enterNode t.Range
-             +> ifElse hasLineCommentBeforeColon unindent sepNone) ctx
+        let genCommentBeforeColon = atCurrentColumn (enterNode t.Range)
 
         let genMetadataAttributes =
             match valInfo with
@@ -538,7 +541,7 @@ and genLetBinding astContext pref b =
     | LetBinding(ats, px, ao, isInline, isMutable, p, e, valInfo) ->
         let genPat =
             match e, p with
-            | TypedExpr(Typed, _, t),  PatLongIdent(ao, s, ps, tpso) when (List.length ps > 1)->
+            | TypedExpr(Typed, _, t),  PatLongIdent(ao, s, ps, tpso) when (List.isNotEmpty ps)->
                 genPatWithReturnType ao s ps tpso (Some t) astContext
             | _,  PatLongIdent(ao, s, ps, tpso) when (List.length ps > 1)->
                 genPatWithReturnType ao s ps tpso None astContext
@@ -2075,9 +2078,9 @@ and genTypeDefn astContext (TypeDef(ats, px, ao, tds, tcs, tdr, ms, s, preferPos
             +> unindent)
 
     | Simple(TDSRUnion(ao', xs) as unionNode) ->
-        let hasLeadingTrivia (t : TriviaNode) = 
+        let hasLeadingTrivia (t : TriviaNode) =
             t.Range = unionNode.Range && not (List.isEmpty t.ContentBefore)
-        
+
         let sepNlnBasedOnTrivia =
             fun (ctx: Context) ->
                 let trivia =
@@ -2092,11 +2095,11 @@ and genTypeDefn astContext (TypeDef(ats, px, ao, tds, tcs, tdr, ms, s, preferPos
             match xs with
             | [] -> ctx
             | [UnionCase(attrs, _,_,_,(UnionCaseType fields)) as x] when List.isEmpty ms ->
-                
-                let hasVerticalBar = 
-                    (Option.isSome ao' && List.length fields <> 1) || 
-                    ctx.Trivia |> List.exists hasLeadingTrivia || 
-                    not (List.isEmpty attrs) || 
+
+                let hasVerticalBar =
+                    (Option.isSome ao' && List.length fields <> 1) ||
+                    ctx.Trivia |> List.exists hasLeadingTrivia ||
+                    not (List.isEmpty attrs) ||
                     List.isEmpty fields
 
                 indent +> sepSpace +> sepNlnBasedOnTrivia
@@ -2955,10 +2958,24 @@ and genPatWithReturnType ao s ps tpso (t:SynType option) (astContext: ASTContext
     let genReturnType, newlineBeforeReturnType =
         match t with
         | Some t -> genType astContext false t, sepNln
-        | None -> sepNone, sepNone
+        | None ->
+            let genReturnType = sepNone
+
+            let newline ctx =
+                if ctx.Config.AlignFunctionSignatureToIndentation then
+                    ctx
+                else
+                    match ps with
+                    | [(_, PatTuple(_))] -> ctx
+                    | _ -> sepNln ctx
 
-    let genParametersWithNewlines =
-        (sepNln +> col sepNln ps (genPatWithIdent astContext) +> newlineBeforeReturnType)
+            genReturnType, newline
+
+    let genParametersWithNewlines ctx =
+        if ctx.Config.AlignFunctionSignatureToIndentation then
+            (indent +> sepNln +> col sepNln ps (genPatWithIdent astContext) +> newlineBeforeReturnType +> unindent) ctx
+        else
+            atCurrentColumn (col sepNln ps (genPatWithIdent astContext) +> newlineBeforeReturnType) ctx
 
     let isLongFunctionSignature (ctx: Context) =
         let space = 1
@@ -2981,7 +2998,7 @@ and genPatWithReturnType ao s ps tpso (t:SynType option) (astContext: ASTContext
         let expr =
             genName
             +> ifElse hasBracket sepOpenT sepNone
-            +> ifElse isLong (indent +> genParametersWithNewlines  +> unindent) genParametersInitial
+            +> ifElse isLong genParametersWithNewlines genParametersInitial
             +> ifElse hasBracket sepCloseT sepNone
 
         expr ctx

src/Fantomas/FormatConfig.fs

@@ -38,6 +38,7 @@ type FormatConfig =
       KeepIfThenInSameLine : bool
       MaxElmishWidth: Num
       SingleArgumentWebMode: bool
+      AlignFunctionSignatureToIndentation: bool
       /// Pretty printing based on ASTs only
       StrictMode : bool }
 
@@ -63,8 +64,9 @@ type FormatConfig =
           MaxValueBindingWidth = 40
           MaxFunctionBindingWidth = 40
           MultilineBlockBracketsOnSameColumn = false
+          NewlineBetweenTypeDefinitionAndMembers = false
           KeepIfThenInSameLine = false
           MaxElmishWidth = 40
           SingleArgumentWebMode = false
-          NewlineBetweenTypeDefinitionAndMembers = false
+          AlignFunctionSignatureToIndentation = false
           StrictMode = false }