40 columns                              |
>>> chain of same logic all split together
if (object case first || second || third || fourth) {;}
<<<
if (object
    case first ||
        second ||
        third ||
        fourth) {
  ;
}
>>> chains of different logic operators split separately
if (object case first && second || third && fourth && fifth && sixth) {;}
<<<
if (object
    case first && second ||
        third &&
            fourth &&
            fifth &&
            sixth) {
  ;
}
>>> chains of different logic operators split separately
if (object case first && second && third && fourth || fifth && sixth) {;}
<<<
if (object
    case first &&
            second &&
            third &&
            fourth ||
        fifth && sixth) {
  ;
}
>>> split in relational constant expression
if (object case != veryLongConstant + expressionThatSplits) {;}
<<<
if (object
    case != veryLongConstant +
        expressionThatSplits) {
  ;
}
>>> split in cast
if (object case veryLongConstant as VeryLongType) {;}
<<<
if (object
    case veryLongConstant
        as VeryLongType) {
  ;
}
>>> split in qualified name
if (object case veryLongPrefix.longIdentifierName) {;}
<<<
if (object
    case veryLongPrefix
        .longIdentifierName) {
  ;
}
>>> prefer to split in first part prefixed qualified name
if (object case longPrefix.longType.longIdentifierName) {;}
<<<
if (object
    case longPrefix
        .longType
        .longIdentifierName) {
  ;
}
>>> split just at second part of prefixed qualified name
if (object case longPrefix.veryLongType.longIdentifierName) {;}
<<<
if (object
    case longPrefix
        .veryLongType
        .longIdentifierName) {
  ;
}
>>> split both parts of prefixed qualified name
if (object case veryLongPrefixIdentifier.veryLongType.longIdentifierName) {;}
<<<
if (object
    case veryLongPrefixIdentifier
        .veryLongType
        .longIdentifierName) {
  ;
}
>>> no split after "var"
if (obj case var thisIsReallyQuiteAVeryLongVariableName) {;}
<<<
if (obj
    case var thisIsReallyQuiteAVeryLongVariableName) {
  ;
}
>>> no split after "final"
if (obj case final thisIsReallyQuiteAVeryLongVariableName) {;}
<<<
if (obj
    case final thisIsReallyQuiteAVeryLongVariableName) {
  ;
}
>>> no split between "final" and type
if (obj case final ThisIsReallyQuiteAVeryLongTypeName variable) {;}
<<<
if (obj
    case final ThisIsReallyQuiteAVeryLongTypeName
        variable) {
  ;
}
>>> split between type and name
if (obj case SomeLongTypeName longVariableName) {
  ;
}
<<<
if (obj
    case SomeLongTypeName
        longVariableName) {
  ;
}
>>> unsplit list
if (obj case [1, ...var x, 3]) {;}
<<<
if (obj case [1, ...var x, 3]) {
  ;
}
>>> if it splits anywhere, it splits at every element
if (obj case [first,second,third,fourth]) {;}
<<<
if (obj
    case [
      first,
      second,
      third,
      fourth,
    ]) {
  ;
}
>>> split in element forces list to split
if (obj case [first,secondLongPattern ||thirdLongPattern]) {;}
<<<
if (obj
    case [
      first,
      secondLongPattern ||
          thirdLongPattern,
    ]) {
  ;
}
>>> a trailing comma forces a split
if (obj case [1,]) {;}
<<<
if (obj case [1]) {
  ;
}
>>> does not split after "..."
if (obj case [...firstPattern || secondLongPattern]) {;}
<<<
if (obj
    case [
      ...firstPattern ||
          secondLongPattern,
    ]) {
  ;
}
>>> nested list patterns don't force outer to split
if (obj case [[1, 2], [[3]]]) {;}
<<<
if (obj case [[1, 2], [[3]]]) {
  ;
}
>>> list constant in list pattern doesn't force pattern to split
if (obj case [const [1, 2]]) {;}
<<<
if (obj case [const [1, 2]]) {
  ;
}
>>> preserve newlines in list containing a line comment
if (obj case [
  // yeah
  a,b,c,
  d,e,f,
]) {;}
<<<
if (obj
    case [
      // yeah
      a, b, c,
      d, e, f,
    ]) {
  ;
}
>>> split in type argument but not body
if (obj case <Map<VeryLongTypeArgument, VeryLongTypeArgument>>[e]) {;}
<<<
if (obj
    case <
      Map<
        VeryLongTypeArgument,
        VeryLongTypeArgument
      >
    >[e]) {
  ;
}
>>> split in type argument and body
if (obj case <Map<VeryLongTypeArgument, VeryLongTypeArgument>>[element]) {;}
<<<
if (obj
    case <
      Map<
        VeryLongTypeArgument,
        VeryLongTypeArgument
      >
    >[element]) {
  ;
}
>>> unsplit map
if (obj case {k: 1, m: 3, ...}) {;}
<<<
if (obj case {k: 1, m: 3, ...}) {
  ;
}
>>> if it splits anywhere, it splits at every element
if (obj case {first: 1,second: 2,third: 3}) {;}
<<<
if (obj
    case {
      first: 1,
      second: 2,
      third: 3,
    }) {
  ;
}
>>> split in value forces map to split
if (obj case {k: first, m: secondLongPattern ||thirdLongPattern}) {;}
<<<
if (obj
    case {
      k: first,
      m: secondLongPattern ||
          thirdLongPattern,
    }) {
  ;
}
>>> a trailing comma forces a split
if (obj case {k:1,}) {;}
<<<
if (obj case {k: 1}) {
  ;
}
>>> nested map patterns don't force outer to split
if (obj case {a: {k: 1}, m: [{k: 3}]}) {;}
<<<
if (obj case {a: {k: 1}, m: [{k: 3}]}) {
  ;
}
>>> map constant in map pattern doesn't force pattern to split
if (obj case {k: const {1: 2}}) {;}
<<<
if (obj case {k: const {1: 2}}) {
  ;
}
>>> preserve newlines in maps containing a line comment
if (obj case {
  // yeah
  a:1,b:2,c:3,
  d:4,e:5,f:6,
}) {;}
<<<
if (obj
    case {
      // yeah
      a: 1, b: 2, c: 3,
      d: 4, e: 5, f: 6,
    }) {
  ;
}
>>> single-element records don't have to split
if (obj case (pattern,)) {;}
<<<
if (obj case (pattern,)) {
  ;
}
>>> single-element records can split after ","
if (obj case (veryLongRecordField____________,)) {;}
<<<
if (obj
    case (
      veryLongRecordField____________,
    )) {
  ;
}
>>> split single-element named record
if (obj case (longFieldName: longRecordFieldValu)) {;}
<<<
if (obj
    case (
      longFieldName: longRecordFieldValu
    )) {
  ;
}
>>> split single-element named record at name
if (obj case (longFieldName: veryLongRecordFieldValue)) {;}
<<<
if (obj
    case (
      longFieldName:
          veryLongRecordFieldValue
    )) {
  ;
}
>>> split single-element record with inferred name
if (obj case (:var veryLongInferredFieldName_____)) {;}
<<<
if (obj
    case (
      :var veryLongInferredFieldName_____
    )) {
  ;
}
>>> split before inferred field name
if (obj case (:var firstLongInferredFieldName, :var secondLongInferredName)) {;}
<<<
if (obj
    case (
      :var firstLongInferredFieldName,
      :var secondLongInferredName,
    )) {
  ;
}
>>> don't split between name and list subpattern
if (obj case (longFieldName: [first, second, third])) {;}
<<<
if (obj
    case (
      longFieldName: [
        first,
        second,
        third,
      ]
    )) {
  ;
}
>>> don't split between name and map subpattern
if (obj case (longFieldName: {first: 1, second: 2})) {;}
<<<
if (obj
    case (
      longFieldName: {
        first: 1,
        second: 2,
      }
    )) {
  ;
}
>>> don't split between name and record subpattern
if (obj case (longFieldName: (first: 1, second: 2))) {;}
<<<
if (obj
    case (
      longFieldName: (
        first: 1,
        second: 2,
      )
    )) {
  ;
}
>>> don't split between name and constant list
if (obj case (longFieldName: const [first, second, third])) {;}
<<<
if (obj
    case (
      longFieldName: const [
        first,
        second,
        third,
      ]
    )) {
  ;
}
>>> don't split between name and constant map
if (obj case (longFieldName: const {first: 1, second: 2})) {;}
<<<
if (obj
    case (
      longFieldName: const {
        first: 1,
        second: 2,
      }
    )) {
  ;
}
>>> don't split between name and const record
if (obj case (longFieldName: const (first: 1, second: 2))) {;}
<<<
if (obj
    case (
      longFieldName: const (
        first: 1,
        second: 2,
      )
    )) {
  ;
}
>>> if any field splits, all do
if (obj case (first, second, third, fourth, fifth)) {;}
<<<
if (obj
    case (
      first,
      second,
      third,
      fourth,
      fifth,
    )) {
  ;
}
>>> don't force outer record to split
if (obj case ((a,), (b, c))) {;}
<<<
if (obj case ((a,), (b, c))) {
  ;
}
>>> nested split record
if (obj case (first, (second, third, fourth), fifth, (sixth, seventh, eighth, nine, tenth,
    eleventh))) {;}
<<<
if (obj
    case (
      first,
      (second, third, fourth),
      fifth,
      (
        sixth,
        seventh,
        eighth,
        nine,
        tenth,
        eleventh,
      ),
    )) {
  ;
}
>>> preserve newlines in records containing a line comment
if (obj case (
  // yeah
  a,b,c,
  d,e,f,
)) {;}
<<<
if (obj
    case (
      // yeah
      a, b, c,
      d, e, f,
    )) {
  ;
}
>>> split list constant in pattern
if (obj case const [element, element, element, element]) {;}
<<<
if (obj
    case const [
      element,
      element,
      element,
      element,
    ]) {
  ;
}
>>> split map constant in pattern
if (obj case const {a: element, b: element, c: element}) {;}
<<<
if (obj
    case const {
      a: element,
      b: element,
      c: element,
    }) {
  ;
}
>>> split set constant in pattern
if (obj case const {element, element, element, element}) {;}
<<<
if (obj
    case const {
      element,
      element,
      element,
      element,
    }) {
  ;
}
>>> split record constant in pattern
if (obj case const (element, element, element, element)) {;}
<<<
if (obj
    case const (
      element,
      element,
      element,
      element,
    )) {
  ;
}
>>> split constant constructor in pattern
if (obj case const Foo(element, element, element, element)) {;}
<<<
if (obj
    case const Foo(
      element,
      element,
      element,
      element,
    )) {
  ;
}
>>> single-element objects with trailing commas split
if (obj case Foo(:pattern,)) {;}
<<<
if (obj case Foo(:pattern)) {
  ;
}
>>> split single-element object
if (obj case Foo(longFieldName: longObjectFieldValu)) {;}
<<<
if (obj
    case Foo(
      longFieldName:
          longObjectFieldValu,
    )) {
  ;
}
>>> split field at name
if (obj case Foo(longFieldName: veryLongObjectFieldValue)) {;}
<<<
if (obj
    case Foo(
      longFieldName:
          veryLongObjectFieldValue,
    )) {
  ;
}
>>> split single-element object with inferred name
if (obj case Foo(:var veryLongInferredFieldName_____)) {;}
<<<
if (obj
    case Foo(
      :var veryLongInferredFieldName_____,
    )) {
  ;
}
>>> split before inferred field name
if (obj case Foo(:var firstLongInferredFieldName, :var secondLongInferredName)) {;}
<<<
if (obj
    case Foo(
      :var firstLongInferredFieldName,
      :var secondLongInferredName,
    )) {
  ;
}
>>> don't split between name and list subpattern
if (obj case Foo(longFieldName: [first, second, third])) {;}
<<<
if (obj
    case Foo(
      longFieldName: [
        first,
        second,
        third,
      ],
    )) {
  ;
}
>>> don't split between name and map subpattern
if (obj case Foo(longFieldName: {first: 1, second: 2})) {;}
<<<
if (obj
    case Foo(
      longFieldName: {
        first: 1,
        second: 2,
      },
    )) {
  ;
}
>>> don't split between name and record subpattern
if (obj case Foo(longFieldName: (first: 1, second: 2))) {;}
<<<
if (obj
    case Foo(
      longFieldName: (
        first: 1,
        second: 2,
      ),
    )) {
  ;
}
>>> don't split between name and constant list
if (obj case Foo(longFieldName: const [first, second, third])) {;}
<<<
if (obj
    case Foo(
      longFieldName: const [
        first,
        second,
        third,
      ],
    )) {
  ;
}
>>> don't split between name and constant map
if (obj case Foo(longFieldName: const {first: 1, second: 2})) {;}
<<<
if (obj
    case Foo(
      longFieldName: const {
        first: 1,
        second: 2,
      },
    )) {
  ;
}
>>> don't split between name and const record
if (obj case Foo(longFieldName: const (first: 1, second: 2))) {;}
<<<
if (obj
    case Foo(
      longFieldName: const (
        first: 1,
        second: 2,
      ),
    )) {
  ;
}
>>> if any field splits, all do
if (obj case Foo(first, second, third, fourth, fifth)) {;}
<<<
if (obj
    case Foo(
      first,
      second,
      third,
      fourth,
      fifth,
    )) {
  ;
}
>>> don't force outer object to split
if (obj case Foo(Bar(a: 1, b: 2))) {;}
<<<
if (obj case Foo(Bar(a: 1, b: 2))) {
  ;
}
>>> don't force outer record to split
if (obj case (Foo(a: 1), Bar(b: 2))) {;}
<<<
if (obj case (Foo(a: 1), Bar(b: 2))) {
  ;
}
>>> nested split object
if (obj case Foo(first: 1, Bar(second: 2, third: 3, four: 4), fifth: 5, Baz(sixth: 6, seventh: 7, eighth: 8, nine: 9, tenth: 10,
    eleventh: 11))) {;}
<<<
if (obj
    case Foo(
      first: 1,
      Bar(second: 2, third: 3, four: 4),
      fifth: 5,
      Baz(
        sixth: 6,
        seventh: 7,
        eighth: 8,
        nine: 9,
        tenth: 10,
        eleventh: 11,
      ),
    )) {
  ;
}
>>> preserve newlines in objects containing a line comment
if (obj case Foo(
  // yeah
  a:1,b:2,c:3,
  d:4,e:5,f:6,
)) {;}
<<<
if (obj
    case Foo(
      // yeah
      a: 1, b: 2, c: 3,
      d: 4, e: 5, f: 6,
    )) {
  ;
}
>>> split in type argument
if (obj case LongClassName<First, Second>()) {;}
<<<
if (obj
    case LongClassName<
      First,
      Second
    >()) {
  ;
}
>>> split in type argument and body
if (obj case LongClassName<First, Second, Third>(first: 1, second: 2, third: 3)) {;}
<<<
if (obj
    case LongClassName<
      First,
      Second,
      Third
    >(first: 1, second: 2, third: 3)) {
  ;
}
>>> split in parenthesized constant expression
if (obj case const(longArgument + anotherArgument)) {;}
<<<
if (obj
    case const (longArgument +
        anotherArgument)) {
  ;
}