Fix CI failures from signature roundtrip changes

- NicePrint: null-safe typar name handling in layoutTyparRef to avoid
  NRE when rendering anonymous typars during overload resolution.
- NicePrint: deduplicate SRTP constraints in layoutNonMemberVal so they
  appear only in typar decl brackets, not duplicated in the postfix
  'when' clause.
- PrettyNaming: revert active-pattern case backtick escaping from
  ConvertValLogicalNameToDisplayNameCore (which is also used by
  tryParseActivePatternName parsing path). Apply backtick escaping only
  at final display layer via new escapeActivePatternCaseNames helper in
  ConvertValLogicalNameToDisplayName and ConvertValLogicalNameToDisplayLayout.
- Update IWSAMsAndSRTPs signature test expectations to match new
  val inline f<^T ...> : ... format.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: T-Gro

src/Compiler/Checking/NicePrint.fs

@@ -730,7 +730,12 @@ module PrintTypes =
         | _, _ -> squareAngleL (sepListL RightL.semicolon ((match kind with TyparKind.Type -> [] | TyparKind.Measure -> [wordL (tagText "Measure")]) @ List.map (layoutAttrib denv) attrs)) ^^ restL
 
     and layoutTyparRef denv (typar: Typar) =
-        let name = NormalizeIdentifierBackticks (typar.DeclaredName |> Option.defaultValue typar.Name)
+        let rawName =
+            match typar.DeclaredName with
+            | Some n when not (isNull (box n)) -> n
+            | _ -> typar.Name
+        let name =
+            if isNull (box rawName) then "" else NormalizeIdentifierBackticks rawName
         tagTypeParameter 
             (sprintf "%s%s%s"
                 (if denv.showStaticallyResolvedTyparAnnotations then prefixOfStaticReq typar.StaticReq else "'")
@@ -1502,6 +1507,15 @@ module PrintTastMemberOrVals =
     let layoutNonMemberVal denv (tps, v: Val, tau, cxs) =
         let env = SimplifyTypes.CollectInfo true [tau] cxs
         let cxs = env.postfixConstraints
+        let hasStaticallyResolvedTypars =
+            tps |> List.exists (fun (tp: Typar) -> tp.StaticReq = TyparStaticReq.HeadType) &&
+            not (IsLogicalOpName v.LogicalName)
+        // When SRTP typars are shown on explicit type param declarations, exclude
+        // their constraints from the postfix to avoid duplicated "when" clauses.
+        let cxs =
+            if hasStaticallyResolvedTypars then
+                cxs |> List.filter (fun (tp, _) -> tp.StaticReq <> TyparStaticReq.HeadType)
+            else cxs
         let valReprInfo = arityOfValForDisplay v
         let argInfos, retTy = GetTopTauTypeInFSharpForm denv.g valReprInfo.ArgInfos tau v.Range
         let nameL =
@@ -1535,9 +1549,6 @@ module PrintTastMemberOrVals =
         let isTyFunction = v.IsTypeFunction // Bug: 1143, and innerpoly tests
         let typarOrderMismatch = isTyparOrderMismatch tps argInfos
 
-        let hasStaticallyResolvedTypars =
-            tps |> List.exists (fun tp -> tp.StaticReq = TyparStaticReq.HeadType) &&
-            not (IsLogicalOpName v.LogicalName)
         let typarBindingsL = 
             if isTyFunction || isOverGeneric || denv.showTyparBinding || typarOrderMismatch || hasStaticallyResolvedTypars then 
                 layoutTyparDecls denv nameL true tps 

src/Compiler/SyntaxTree/PrettyNaming.fs

@@ -501,24 +501,29 @@ let ConvertValLogicalNameToDisplayNameCore opName =
     match standardOpsDecompile.TryGetValue opName with
     | true, res -> res
     | false, _ ->
-        if IsActivePatternName opName then
-            // Active pattern case names may need backtick escaping (e.g. |``A B``|)
-            let inner = opName.[1 .. opName.Length - 2] // strip outer | |
-            let cases = inner.Split('|')
-
-            let escapedCases =
-                cases
-                |> Array.map (fun c ->
-                    if c = "_" then c
-                    elif not (IsIdentifierName c) then "``" + c + "``"
-                    else c)
-
-            "|" + (escapedCases |> String.concat "|") + "|"
-        elif IsPossibleOpName opName then
+        if IsPossibleOpName opName then
             decompileCustomOpName opName
         else
             opName
 
+/// For active pattern names, optionally escape individual case names that are not valid F# identifiers
+/// with backticks (e.g. |A B| -> |``A B``|). Leaves well-formed identifier cases alone.
+let private escapeActivePatternCaseNames (opName: string) =
+    if IsActivePatternName opName then
+        let inner = opName.[1 .. opName.Length - 2]
+        let cases = inner.Split('|')
+
+        let escapedCases =
+            cases
+            |> Array.map (fun c ->
+                if c = "_" then c
+                elif not (IsIdentifierName c) then "``" + c + "``"
+                else c)
+
+        "|" + (escapedCases |> String.concat "|") + "|"
+    else
+        opName
+
 let DoesIdentifierNeedBackticks (name: string) : bool =
     not (IsUnencodedOpName name)
     && not (IsIdentifierName name)
@@ -558,8 +563,9 @@ let ConvertValLogicalNameToDisplayName isBaseVal name =
         // Add parentheses for multiply-like symbols, with spacing to avoid confusion with comments
         elif nm <> "*" && (nm.StartsWithOrdinal "*" || nm.EndsWithOrdinal "*") then
             "( " + nm + " )"
-        // Add parentheses for other symbols, no spacing
+        // Add parentheses for other symbols, no spacing; escape active pattern case names that aren't identifiers
         else
+            let nm = escapeActivePatternCaseNames nm
             "(" + nm + ")"
     else
         ConvertLogicalNameToDisplayName name
@@ -585,6 +591,8 @@ let ConvertValLogicalNameToDisplayLayout isBaseVal nonOpLayout name =
             ^^ wordL (TaggedText.tagOperator nm)
             ^^ wordL (TaggedText.tagPunctuation ")")
         else
+            let nm = escapeActivePatternCaseNames nm
+
             leftL (TaggedText.tagPunctuation "(")
             ^^ wordL (TaggedText.tagOperator nm)
             ^^ rightL (TaggedText.tagPunctuation ")")

tests/FSharp.Compiler.ComponentTests/Conformance/Types/TypeConstraints/IWSAMsAndSRTPs/IWSAMsAndSRTPsTests.fs

@@ -80,24 +80,24 @@ let main _ =
 
     [<Theory>]
     [<InlineData("let inline f0 (x: ^T) = x",
-                 "val inline f0: x: ^T -> ^T")>]
+                 "val inline f0<^T> : x: ^T -> ^T")>]
 
     [<InlineData("""
                  let inline f0 (x: ^T) = x
                  let g0 (x: 'T) = f0 x""",
                  "val g0: x: 'T -> 'T")>]
 
     [<InlineData("let inline f1 (x: ^T) = (^T : (static member A: int) ())",
-                 "val inline f1: x: ^T -> int when ^T: (static member A: int)")>]
+                 "val inline f1<^T when ^T: (static member A: int)> : x: ^T -> int")>]
 
     [<InlineData("let inline f2 (x: 'T) = ((^T or int) : (static member A: int) ())",
-                 "val inline f2: x: ^T -> int when (^T or int) : (static member A: int)")>]
+                 "val inline f2<^T when (^T or int) : (static member A: int)> : x: ^T -> int")>]
 
     [<InlineData("let inline f3 (x: 'T) = ((^U or 'T) : (static member A: int) ())",
-                 "val inline f3: x: ^T -> int when (^U or ^T) : (static member A: int)")>]
+                 "val inline f3<^T,^U when (^U or ^T) : (static member A: int)> : x: ^T -> int")>]
 
     [<InlineData("let inline f4 (x: 'T when 'T : (static member A: int) ) = 'T.A",
-                "val inline f4: x: ^T -> int when ^T: (static member A: int)")>]
+                "val inline f4<^T when ^T: (static member A: int)> : x: ^T -> int")>]
 
     [<InlineData("""
              let inline f5 (x: ^T) = printfn "%d" x
@@ -106,11 +106,11 @@ let main _ =
     [<InlineData("""
              let inline f5 (x: ^T) = printfn "%d" x
              let inline h5 (x: 'T) = f5 x""",
-                 "val inline h5: x: ^T -> unit when ^T: (byte|int16|int32|int64|sbyte|uint16|uint32|uint64|nativeint|unativeint)")>]
+                 "val inline h5<^T when ^T: (byte|int16|int32|int64|sbyte|uint16|uint32|uint64|nativeint|unativeint)> : x: ^T -> unit")>]
     [<InlineData("""
              let inline uint32 (value: ^T) = (^T : (static member op_Explicit: ^T -> uint32) (value))
              let inline uint value = uint32 value""",
-                 "val inline uint: value: ^a -> uint32 when ^a: (static member op_Explicit: ^a -> uint32)")>]
+                 "val inline uint<^a when ^a: (static member op_Explicit: ^a -> uint32)> : value: ^a -> uint32")>]
 
     [<InlineData("let checkReflexive f x y = (f x y = - f y x)",
                  "val checkReflexive: f: ('a -> 'a -> int) -> x: 'a -> y: 'a -> bool")>]