pattern matched unions are formatted badly

[7sharp9]

Using sourceTransformer.fs from this repo

let rec multiline synExpr = 
    match synExpr with
    | ConstExpr _
    | NullExpr
    | OptVar _
    | SequentialSimple _ ->
        false

    | ObjExpr _
    | While _
    | For _
    | ForEach _
    | TryWith _
    | TryFinally _
    | Sequentials _
    | IfThenElse _ ->
        true

    | Paren e
    | SingleExpr(_, e)
    | TypedExpr(_, e, _)
    | CompExpr(_, e)
    | ArrayOrListOfSeqExpr(_, e)
    | DesugaredLambda(_, e)
    | Lambda(e, _)
    | TypeApp(e, _)
    | LongIdentSet(_, e)
    | DotGet(e, _)
    | TraitCall(_, _, e) ->
        multiline e
...

is formatted into this:

let rec multiline synExpr =
    match synExpr with
    | ConstExpr _ | NullExpr | OptVar _ | SequentialSimple _ -> false
    | ObjExpr _ | While _ | For _ | ForEach _ | TryWith _ | TryFinally _ | Sequentials _ | IfThenElse _ -> true
    | Paren e | SingleExpr(_, e) | TypedExpr(_, e, _) | CompExpr(_, e) | ArrayOrListOfSeqExpr(_, e) | DesugaredLambda(_, 
                                                                                                                      e) | Lambda(e, 
                                                                                                                                  _) | TypeApp(e, 
                                                                                                                                               _) | LongIdentSet(_, 
                                                                                                                                                                 e) | DotGet(e, 
                                                                                                                                                                             _) | TraitCall(_, 
                                                                                                                                                                                            _, 
                                                                                                                                                                                            e) -> 
        multiline e

Another piece of code in this file:

let (|OneLinerBinding|MultilineBinding|) b =
    match b with
    | LetBinding([], PreXmlDoc [||], _, _, _, _, OneLinerExpr _)
    | DoBinding([], PreXmlDoc [||], OneLinerExpr _)
    | MemberBinding([], PreXmlDoc [||], _, _, _, _, OneLinerExpr _)
    | PropertyBinding([], PreXmlDoc [||], _, _, _, _, OneLinerExpr _) 
    | ExplicitCtor([], PreXmlDoc [||], _, _, OneLinerExpr _, _) -> 
        OneLinerBinding b

    | _ -> MultilineBinding b

Is formatted to this:

let (|OneLinerMemberDefn|MultilineMemberDefn|) md =
    match md with
    | MDOpen _ | MDInherit _ | MDValField _ | MDImplicitCtor _ | MDInterface(_, None) | MDAbstractSlot([], 
                                                                                                       PreXmlDoc [||], _, 
                                                                                                       _, _, _, _, _) | MDImplicitInherit(_, 
                                                                                                                                          OneLinerExpr _, 
                                                                                                                                          _) | MDMember(OneLinerBinding _) | MDAutoProperty([], 
                                                                                                                                                                                            PreXmlDoc [||], 
                                                                                                                                                                                            _, 
                                                                                                                                                                                            _, 
                                                                                                                                                                                            OneLinerExpr _, 
                                                                                                                                                                                            _, 
                                                                                                                                                                                            _, 
                                                                                                                                                                                            _, 
                                                                                                                                                                                            _) | MDLetBindings(_, 
                                                                                                                                                                                                               _, 
                                                                                                                                                                                                               [ OneLinerBinding _ ]) -> 
        OneLinerMemberDefn md
    | _ -> MultilineMemberDefn md

There are multiple issues with indentation and union filed components being moved down a line.

[vasily-kirichenko]

@7sharp9 What about using FormatConfig.PreserveEndOfLine = true? I've tested your first sample and it's not changed at all after formatting.

[7sharp9]

I suppose but thats just disabling the issue

[nojaf]

Would it be ok to state that every case inside a pattern match should be on a newline?
Style guide says If the expression is short, you can consider using a single line if each subexpression is also simple..

However to me it doesn't seem like the end of the world if we go with an opinionated approach and go with a line anyway. Or does anyone have a good heuristic in mind?

[jindraivanek]

Fixed by #391.