Merge pull request #3248 from nojaf/fix-3243

Fix closing > in nested multiline generic type applications

Author: nojaf

CHANGELOG.md

@@ -8,6 +8,7 @@
 
 ### Fixed
 
+- Closing `>` in nested multiline generic type applications violates offside rule. [#3243](https://github.com/fsprojects/fantomas/issues/3243)
 - Lambda in non-last record field is now parenthesized when record is collapsed to single line to avoid producing invalid code. [#3246](https://github.com/fsprojects/fantomas/issues/3246)
 
 ## [8.0.0-alpha-003] - 2026-03-03

scripts/format.fsx

@@ -8,7 +8,16 @@ let format (input: string) (isSignature: bool) (config: FormatConfig) =
     async {
         try
             let! result = CodeFormatter.FormatDocumentAsync(isSignature, input, config)
-            return result.Code
+            let formattedCode = result.Code
+
+            // Check for diagnostics in the formatted output
+            let sourceText = Fantomas.FCS.Text.SourceText.ofString formattedCode
+            let _, diagnostics = Fantomas.FCS.Parse.parseFile isSignature sourceText []
+
+            for d in diagnostics do
+                eprintfn "Diagnostic: %A %A %s %A" d.Severity d.ErrorNumber d.Message d.Range
+
+            return formattedCode
         with ex ->
             return $"Error while formatting: %A{ex}"
     }

src/Fantomas.Core.Tests/TypeAnnotationTests.fs

@@ -134,7 +134,7 @@ type CancellableTaskResultBuilderBase with
                             'TOverall,
                             'Error,
                             'TResult2
-                         >)
+                            >)
         ) : bool =
         true
 """

src/Fantomas.Core.Tests/TypeAppTests.fs

@@ -502,3 +502,88 @@ let bv =
      >
         bf
 """
+
+[<Test>]
+let ``nested multiline type app should not produce invalid code, 3243`` () =
+    formatSourceString
+        """
+let f (x: Outer<Map<string, (A * B * C * D)>, Z>) = ()
+"""
+        { config with MaxLineLength = 30 }
+    |> prepend newline
+    |> should
+        equal
+        """
+let f
+    (x:
+        Outer<
+            Map<
+                string,
+                (A * B * C * D)
+             >,
+            Z
+         >)
+    =
+    ()
+"""
+
+[<Test>]
+let ``nested multiline type app in function signature should not produce invalid code, 3243`` () =
+    formatSourceString
+        """
+let makePipeline''
+    (mode: ExecutionMode<Marker>)
+    (resolver: IResolver option Marker)
+    (args: Arguments Marker)
+    (logging: Marker<ExtraLogging>)
+    (processing:
+        (PipelineStep<
+            Map<string,
+                ((Table * IStepMetadata)
+                 * Operation seq
+                 * FileInfo ResultKind seq
+                 * (NodeInfo<string, string> * DayLogs) seq)>,
+            PipelineCrate>)
+            ->
+        (Map<string,
+            ((Table * IStepMetadata)
+             * Operation seq
+             * FileInfo ResultKind seq
+             * (NodeInfo<string, string> * DayLogs) seq)> Marker)
+            ->
+        PipelineStep<unit>)
+    =
+    ()
+"""
+        config
+    |> prepend newline
+    |> should
+        equal
+        """
+let makePipeline''
+    (mode: ExecutionMode<Marker>)
+    (resolver: IResolver option Marker)
+    (args: Arguments Marker)
+    (logging: Marker<ExtraLogging>)
+    (processing:
+        (PipelineStep<
+            Map<
+                string,
+                ((Table * IStepMetadata) *
+                Operation seq *
+                FileInfo ResultKind seq *
+                (NodeInfo<string, string> * DayLogs) seq)
+             >,
+            PipelineCrate
+          >)
+            -> (Map<
+                string,
+                ((Table * IStepMetadata) *
+                Operation seq *
+                FileInfo ResultKind seq *
+                (NodeInfo<string, string> * DayLogs) seq)
+                 > Marker)
+            -> PipelineStep<unit>)
+    =
+    ()
+"""

src/Fantomas.Core/CodePrinter.fs

@@ -1193,19 +1193,20 @@ let genExpr (e: Expr) =
                         else
                             indentSepNlnUnindent f ctx
 
-                    let genFuncExpr =
-                        match node.FunctionExpr with
-                        | Expr.TypeApp node -> genTypeApp true node
-                        | _ -> genExpr node.FunctionExpr
-
-                    (genFuncExpr
+                    (genExpr node.FunctionExpr
                      +> ensureArgumentsAreNotAlignedWithFunctionName (col sepNln node.Arguments genExpr))
                         ctx
 
                 expressionFitsOnRestOfLine shortExpression longExpression ctx
 
         |> genNode node
-    | Expr.TypeApp node -> expressionFitsOnRestOfLine (genTypeApp false node) (genTypeApp true node)
+    | Expr.TypeApp node ->
+        genPrefixApp
+            (genExpr node.Identifier)
+            node.LessThan
+            (colGenericTypeParameters node.TypeParameters)
+            node.GreaterThan
+        |> genNode node
     | Expr.TryWithSingleClause node ->
         let genClause =
             let clauseNode = node.Clause
@@ -2093,26 +2094,6 @@ let genAppSingleParenArgExpr (addSpace: Context -> Context) (node: ExprAppSingle
 
     expressionFitsOnRestOfLine short long |> genNode node
 
-/// When called from `SynExpr.App` we need to ensure the node.GreaterThan is placed one space further than the start column.
-/// This is to ensure the application remains an application.
-let genTypeApp (addAdditionalColumnOffset: bool) (node: ExprTypeAppNode) (ctx: Context) : Context =
-    genNode
-        node
-        (fun ctx ->
-            // Capture startColumn inside genNode (after leading trivia/newlines are written),
-            // so we get the column on the actual line, not a stale column from a previous line. See #3179.
-            let startColumn = ctx.Column + (if addAdditionalColumnOffset then 1 else 0)
-
-            (genExpr node.Identifier
-             +> genSingleTextNode node.LessThan
-             +> colGenericTypeParameters node.TypeParameters
-             // we need to make sure each expression in the function application has offset at least greater than
-             // See: https://github.com/fsprojects/fantomas/issues/1611
-             +> addFixedSpaces startColumn
-             +> genSingleTextNode node.GreaterThan)
-                ctx)
-        ctx
-
 let genClauses (clauses: MatchClauseNode list) =
     let lastIndex = clauses.Length - 1
 
@@ -2377,6 +2358,24 @@ let colGenericTypeParameters typeParameters =
     | [ Type.StaticConstant(Constant.FromText textNode) ] when textNode.Text.Contains("\n") -> short
     | _ -> expressionFitsOnRestOfLine short long
 
+/// In F#, a closing `>` on a new line is ambiguous with the comparison operator.
+/// Formats `identifier< typeParameters >` while ensuring the closing `>` satisfies F#'s offside rule.
+let genPrefixApp
+    (identifier: Context -> Context)
+    (lessThan: SingleTextNode)
+    (typeParameters: Context -> Context)
+    (greaterThan: SingleTextNode)
+    (ctx: Context)
+    : Context =
+    let startColumn = ctx.Column
+
+    (identifier
+     +> genSingleTextNode lessThan
+     +> typeParameters
+     +> addFixedSpaces (startColumn + 1)
+     +> genSingleTextNode greaterThan)
+        ctx
+
 let genFunctionNameWithMultilineLids (trailing: Context -> Context) (longIdent: IdentListNode) =
     match longIdent.Content with
     | IdentifierOrDot.Ident identNode :: t ->
@@ -3254,15 +3253,11 @@ let genType (t: Type) =
             | Type.Var node :: _ when String.startsWithOrdinal "^" node.Text -> sepSpace
             | t :: _ -> addSpaceIfSynTypeStaticConstantHasAtSignBeforeString t
 
-        genType node.Identifier
-        +> optSingle genIdentListNodeWithDot node.PostIdentifier
-        +> genSingleTextNode node.LessThen
-        +> addExtraSpace
-        +> leadingExpressionIsMultiline (colGenericTypeParameters node.Arguments) (fun isMultiline ->
-            onlyIf isMultiline (!-" "))
-        +> addExtraSpace
-        // TODO: I think we need to add a space here
-        +> genSingleTextNode node.GreaterThan
+        genPrefixApp
+            (genType node.Identifier +> optSingle genIdentListNodeWithDot node.PostIdentifier)
+            node.LessThen
+            (addExtraSpace +> colGenericTypeParameters node.Arguments +> addExtraSpace)
+            node.GreaterThan
         |> genNode node
     | Type.StructTuple node ->
         genSingleTextNode node.Keyword