Don't put = on the same line for when last parameter is single line tuple (#3042)

* Don't put `=` on the same line for when last parameter is single line tuple.

* Update src/Fantomas.Core/CodePrinter.fs

Co-authored-by: dawe <dawedawe@posteo.de>

---------

Co-authored-by: dawe <dawedawe@posteo.de>

Author: nojaf

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [Unreleased]
+
+### Fixed
+* Equals sign should only be on same line if last tuple is multiline. [#3040](https://github.com/fsprojects/fantomas/issues/3040)
+
 ## 6.3.0-alpha-007 - 2024-01-27
 
 ### Changed

src/Fantomas.Core.Tests/CrampedMultilineBracketStyleTests.fs

@@ -1490,7 +1490,8 @@ type RequestParser<'ctx, 'a> =
           prohibited: ProhibitedRequestGetter list }
 
     static member internal Create
-        (consumedFields, parse: 'ctx -> Request -> Async<Result<'a, Error list>>) : RequestParser<'ctx, 'a> =
+        (consumedFields, parse: 'ctx -> Request -> Async<Result<'a, Error list>>)
+        : RequestParser<'ctx, 'a> =
         { consumedFields = consumedFields
           parse = parse
           prohibited = [] }

src/Fantomas.Core.Tests/FunctionDefinitionTests.fs

@@ -1106,7 +1106,8 @@ let longFunctionWithLongTupleParameter
         equal
         """
 let longFunctionWithLongTupleParameter
-    (aVeryLongParam, aSecondVeryLongParam, aThirdVeryLongParam, aFourthVeryLongParam) =
+    (aVeryLongParam, aSecondVeryLongParam, aThirdVeryLongParam, aFourthVeryLongParam)
+    =
     // ... the body of the method follows
     ()
 """

src/Fantomas.Core.Tests/LetBindingTests.fs

@@ -2284,3 +2284,31 @@ let bar
     //
     ()
 """
+
+[<Test>]
+let ``equals sign should not be on same line when last tuple is single line, 3040`` () =
+    formatSourceString
+        """
+let processSnippetLine
+    (checkResults: FSharpCheckFileResults)
+    (semanticRanges: SemanticClassificationItem array)
+    (lines: string array)
+    (line: int, lineTokens: SnippetLine)
+    =
+    let lineStr = lines.[line]
+    ()
+"""
+        config
+    |> prepend newline
+    |> should
+        equal
+        """
+let processSnippetLine
+    (checkResults: FSharpCheckFileResults)
+    (semanticRanges: SemanticClassificationItem array)
+    (lines: string array)
+    (line: int, lineTokens: SnippetLine)
+    =
+    let lineStr = lines.[line]
+    ()
+"""

src/Fantomas.Core/CodePrinter.fs

@@ -2839,6 +2839,8 @@ let genBinding (b: BindingNode) (ctx: Context) : Context =
                         ifElse addSpaceBeforeParensInFunDef sepSpace sepNone
                     | _ -> sepSpace
 
+                /// Format everything in one line:
+                /// let fn p1 p2 : rt =
                 let short =
                     afterLetKeyword
                     +> sepSpace
@@ -2849,12 +2851,54 @@ let genBinding (b: BindingNode) (ctx: Context) : Context =
                     +> sepSpace
                     +> genSingleTextNode b.Equals
 
+                /// Format over multiple lines
+                /// AlternativeLongMemberDefinitions or AlignFunctionSignatureToIndentation can influence the equals and return type.
+                ///
+                /// By default we go with:
+                /// let fn
+                ///     p1
+                ///     p2
+                ///     : rt =
+                ///
+                /// When `rt` is multiline, `=` is placed on the next line:
+                /// let fn
+                ///     p1
+                ///     p2
+                ///     : rt
+                ///     =
+                ///
+                /// When the p2 is a multiline tuple, there are different rules formatting rules:
+                /// let fn
+                ///     p1
+                ///     (
+                ///         p2_1,
+                ///         p2_2,
+                ///         p2_3
+                ///     ) : rt =
+                ///
+                /// AlignFunctionSignatureToIndentation will always place `rt` and `=` on their own lines:
+                /// let fn
+                ///     p1
+                ///     p2
+                ///     : rt
+                ///     =
+                ///
+                /// This happens regardless whether p2 is a multiline tuple:
+                /// let fn
+                ///     p1
+                ///     (
+                ///         p2_1,
+                ///         p2_2,
+                ///         p2_3
+                ///     )
+                ///     : rt
+                ///     =
                 let long (ctx: Context) =
-                    let endsWithTupleParameter =
+                    let endsWithMultilineTupleParameter =
                         match List.tryLast b.Parameters with
-                        | Some(Pattern.Paren parenNode) ->
+                        | Some(Pattern.Paren parenNode as p) ->
                             match parenNode.Pattern with
-                            | Pattern.Tuple _ -> true
+                            | Pattern.Tuple _ -> futureNlnCheck (genLongParenPatParameter p) ctx
                             | _ -> false
                         | _ -> false
 
@@ -2875,21 +2919,21 @@ let genBinding (b: BindingNode) (ctx: Context) : Context =
 
                         beforeInline || beforeIdentifier || beforeAccessibility
 
+                    let nlnOnSeparateLine = not endsWithMultilineTupleParameter || alternativeSyntax
+
                     (onlyIf hasTriviaAfterLeadingKeyword indent
                      +> afterLetKeyword
                      +> sepSpace
                      +> genFunctionName
                      +> indent
                      +> sepNln
                      +> genParameters
-                     +> onlyIf (not endsWithTupleParameter || alternativeSyntax) sepNln
-                     +> leadingExpressionIsMultiline
-                         (genReturnType (not endsWithTupleParameter || alternativeSyntax))
-                         (fun isMultiline ->
-                             if (alternativeSyntax && Option.isSome b.ReturnType) || isMultiline then
-                                 sepNln +> genSingleTextNode b.Equals
-                             else
-                                 sepSpace +> genSingleTextNode b.Equals)
+                     +> onlyIf nlnOnSeparateLine sepNln
+                     +> leadingExpressionIsMultiline (genReturnType nlnOnSeparateLine) (fun isMultiline ->
+                         if (alternativeSyntax && Option.isSome b.ReturnType) || isMultiline then
+                             sepNln +> genSingleTextNode b.Equals
+                         else
+                             sepSpace +> genSingleTextNode b.Equals)
                      +> unindent
                      +> onlyIf hasTriviaAfterLeadingKeyword unindent)
                         ctx