RedundantBraces.stat

rewrite.rules = [RedundantBraces]
rewrite.redundantBraces.maxLines = 1
rewrite.redundantBraces.generalExpressions = true
newlines.afterInfix = some
<<< basic
object a {
  def x(i: Int): Int = {
    2
  }

  def y(i: Int): Int = {
    3
  }
  def z(i: Int): Int = {
    4
  }
}
>>>
object a {
  def x(i: Int): Int =
    2

  def y(i: Int): Int =
    3
  def z(i: Int): Int =
    4
}
<<< basic (format:off)
object a {
// format: off
  def x(i: Int): Int = {
    2
  }

  def y(i: Int): Int = {
    3
  }
  def z(i: Int): Int = {
    4
  }
}

>>>
object a {
// format: off
  def x(i: Int): Int = {
    2
  }

  def y(i: Int): Int = {
    3
  }
  def z(i: Int): Int = {
    4
  }
}
<<< respect max lines
object a {
  def x(i: Int): Int = {
    List.filter { x =>
      // comment
      x > 1
    }
  }
}
>>>
object a {
  def x(i: Int): Int = {
    List.filter { x =>
      // comment
      x > 1
    }
  }
}
<<< single line block
object a {
  def x(i: Int): Int = { 2 }
  def y(i: Int): Int = { 3 }
}
>>>
object a {
  def x(i: Int): Int = 2
  def y(i: Int): Int = 3
}
<<< empty expression
object a {
  def x: Unit = { }
}
>>>
object a {
  def x: Unit = {}
}
<<< right brace on same line as expression
object a {
  def x(i: Int): Int = {
    2 }
  def y(i: Int): Int = { 3 }
}
>>>
object a {
  def x(i: Int): Int =
    2
  def y(i: Int): Int = 3
}
<<< has comment
object a {
  def x(i: Int): Int = { // comment
    2
  }
}
>>>
object a {
  def x(i: Int): Int = // comment
    2
}
<<< has comment 2
object a {
  def x(i: Int): Int = {
    // comment
    2
  }
}
>>>
object a {
  def x(i: Int): Int =
    // comment
    2
}
<<< multiple stats
object a {
  def x(i: Int) = {
    2
    2
  }
}
>>>
object a {
  def x(i: Int) = {
    2
    2
  }
}
<<< procedure syntax
object a {
  def main(args: Seq[Int]) {
    2
  }
}
>>>
object a {
  def main(args: Seq[Int]) {
    2
  }
}
<<< procedure syntax 2
object a {
  def main(args: Seq[Int] = 2) {
    2
  }
}
>>>
object a {
  def main(args: Seq[Int] = 2) {
    2
  }
}
<<< no return type
object a {
  def main(args: Seq[Int] = 2) {
    2
  }
}
>>>
object a {
  def main(args: Seq[Int] = 2) {
    2
  }
}
<<< fixes your nested blocks
object a {
  def x: Int = {{ // comment
      2 } }
}
>>>
object a {
  def x: Int = // comment
    2
}
<<< fixes nested block in multi-line lambda 1
object a {
  method { x => { // 1
        2
        3
        4
     }
  }
}
>>>
object a {
  method { x => // 1
    2
    3
    4
  }
}
<<< fixes nested block in multi-line lambda 2
object a {
  method { x =>
     { // 1
        2
        3
        4
     }
  }
}
>>>
object a {
  method { x =>
    // 1
    2
    3
    4
  }
}
<<< turn block in multi-line paren lambda into curly lambda
object a {
  method ( x =>
     {
        2
        3
        4
     }
  )
}
>>>
object a {
  method { x =>
    2
    3
    4
  }
}
<<< #1027 1.1: braces to parens yes: single-stat
newlines.afterCurlyLambda=squash
===
object a {
  b.c { d =>
   e }
}
>>>
object a {
  b.c(d => e)
}
<<< #1027 1.2: braces to parens no: multi-stat
object a {
  b.c { d =>
   e; f }
}
>>>
object a {
  b.c { d =>
    e; f
  }
}
<<< #1027 1.3: braces to parens no: multi-stat block
object a {
  b.c { d => {
   e; f }}
}
>>>
object a {
  b.c { d =>
    e; f
  }
}
<<< #1027 1.4: braces to parens no: empty body
object a {
  b.c { d => }
}
>>>
object a {
  b.c { d => }
}
<<< #1027 1.5: braces to parens yes: multi-param list
object a {
  b.c(d) { e => f }
}
>>>
object a {
  b.c(d)(e => f)
}
<<< #1027 1.6: braces to parens yes: func of func
object a {
  b.c(d) { implicit e => f => g }
}
>>>
object a {
  b.c(d)(implicit e => f => g)
}
<<< #1027 1.7: braces to parens yes: func of infix
object a {
  b.c(d) { implicit e => f shouldBe g }
}
>>>
object a {
  b.c(d)(implicit e => f shouldBe g)
}
<<< #1027 1.8: braces to parens yes: multiple brace single-arg param-lists
object a {
  b.c(d) { e } { implicit f => g }
}
>>>
object a {
  b.c(d)(e)(implicit f => g)
}
<<< #1027 1.9: braces to parens yes: func of multi-stat func
object a {
  b.c { d => e => { f; g } }
}
>>>
object a {
  b.c(d => e => { f; g })
}
<<< #1027 2.1: parens to braces no
newlines.afterInfix = keep
===
object a {
  b.c (d =>
    e
     + f)
}
>>>
object a {
  b.c(d =>
    e
      + f
  )
}
<<< #1027 2.2: parens to braces no
object a {
  b.c ({d =>    e     + f})
}
>>>
object a {
  b.c({ d => e + f })
}
<<< #1027 3.1: with align
align.preset = more
===
object a {
  val b = c(d => {e}) // comment1
  val bb = cc(dd => {ee}) // comment2
}
>>>
object a {
  val b  = c(d => e)    // comment1
  val bb = cc(dd => ee) // comment2
}
<<< #1027 3.2: with align
align.preset = more
===
object a {
  val b = c(d => {e}) // comment1
  val bb = cc(dd => ee) // comment2
}
>>>
object a {
  val b  = c(d => e)    // comment1
  val bb = cc(dd => ee) // comment2
}
<<< #1027 3.3: with align
align.preset = more
===
object a {
  val b = c(d => {e})(d => {e}) // comment1
  val bb = cc(dd => {ee})(dd => {ee}) // comment2
}
>>>
object a {
  val b  = c(d => e)(d => e)      // comment1
  val bb = cc(dd => ee)(dd => ee) // comment2
}
<<< #1027 3.4: with align
align.preset = more
===
object a {
  val b = c(d => {e})(d => {e}) // comment1
  val bb = cc(dd => ee)(dd => ee) // comment2
}
>>>
object a {
  val b  = c(d => e)(d => e)      // comment1
  val bb = cc(dd => ee)(dd => ee) // comment2
}
<<< #1027 3.5: with align
align.preset = more
===
object a {
  val b = c(d => e)(d => e) // comment1
  val bb = cc(dd => {ee})(dd => {ee(ff =>{gg})}) // comment2
}
>>>
object a {
  val b  = c(d => e)(d => e)                // comment1
  val bb = cc(dd => ee)(dd => ee(ff => gg)) // comment2
}
<<< #1027 3.6: with align, no redundant braces
rewrite.rules = []
align.preset = more
===
object a {
  val b  = c(d => e)(d => e) // comment1
  val bb = cc(dd => {ee})(dd => {ee}) // comment2
}
>>>
object a {
  val b  = c(d => e)(d => e)              // comment1
  val bb = cc(dd => { ee })(dd => { ee }) // comment2
}
<<< #1631
class Test extends AnyWordSpec {
  "SUT" when {
    "statement about test" should {
      "some test" in {
        val s = 1
      }
    }
  }
}
>>>
class Test extends AnyWordSpec {
  "SUT" when {
    "statement about test" should {
      "some test" in {
        val s = 1
      }
    }
  }
}
<<< #1633 1.1: multiline infix
    "properly extract the value of www-urlencoded form fields" in {
      println
      Post("/", urlEncodedForm) ~> {
        formFields('firstName, "age".as[Int], 'sex.?, "VIP" ? false) {
          (firstName, age, sex, vip) ⇒
            complete(firstName + age + sex + vip)
        }
      } ~> check { responseAs[String] shouldEqual "Mike42Nonefalse" }
    }
>>>
"properly extract the value of www-urlencoded form fields" in {
  println
  Post("/", urlEncodedForm) ~> {
    formFields('firstName, "age".as[Int], 'sex.?, "VIP" ? false) {
      (firstName, age, sex, vip) ⇒
        complete(firstName + age + sex + vip)
    }
  } ~> check(responseAs[String] shouldEqual "Mike42Nonefalse")
}
<<< #1633 1.2: func with placeholder and select
object a {
  def findAccountByAPIKey(apiKey: APIKey) = byKeyCache.get(apiKey) match {
    case None =>
      delegate.findAccountByAPIKey(apiKey) map {
         _ map _ tap (add(apiKey, _)) unsafePerformIO
      }
  }
}
>>>
object a {
  def findAccountByAPIKey(apiKey: APIKey) = byKeyCache.get(apiKey) match {
    case None =>
      delegate.findAccountByAPIKey(apiKey) map {
        _ map _ tap (add(apiKey, _)) unsafePerformIO
      }
  }
}
<<< #1633 1.3: func with placeholder and infix
object a {
  def findAccountByAPIKey(apiKey: APIKey) = byKeyCache.get(apiKey) match {
    case None =>
      delegate.findAccountByAPIKey(apiKey) map {
         _ map(_) tap (add(apiKey, _)) unsafePerformIO(foo)
      }
  }
}
>>>
object a {
  def findAccountByAPIKey(apiKey: APIKey) = byKeyCache.get(apiKey) match {
    case None =>
      delegate.findAccountByAPIKey(apiKey) map {
        _ map (_) tap (add(apiKey, _)) unsafePerformIO (foo)
      }
  }
}
<<< #1633 1.4: func
object a {
  def findAccountByAPIKey(apiKey: APIKey) = byKeyCache.get(apiKey) match {
    case None =>
      delegate.findAccountByAPIKey(apiKey) map { x =>
         x._1 map x._2 tap (add(apiKey, _)) unsafePerformIO
      }
  }
}
>>>
object a {
  def findAccountByAPIKey(apiKey: APIKey) = byKeyCache.get(apiKey) match {
    case None =>
      delegate.findAccountByAPIKey(apiKey) map { x =>
        x._1 map x._2 tap (add(apiKey, _)) unsafePerformIO
      }
  }
}
<<< #1633 1.5: partial func
object a {
  def findAccountByAPIKey(apiKey: APIKey) = byKeyCache.get(apiKey) match {
    case None =>
      delegate.findAccountByAPIKey(apiKey) map { case (x,y) =>
         x map y tap (add(apiKey, _)) unsafePerformIO
      }
  }
}
>>>
object a {
  def findAccountByAPIKey(apiKey: APIKey) = byKeyCache.get(apiKey) match {
    case None =>
      delegate.findAccountByAPIKey(apiKey) map { case (x, y) =>
        x map y tap (add(apiKey, _)) unsafePerformIO
      }
  }
}
<<< #1633 2.1: function block in an if-statement
object a {
    val select = if (max) { (a: CTuple, b: CTuple) =>
      (a.compareTo(b) >= 0)
    } else { (a: CTuple, b: CTuple) =>
      (a.compareTo(b) <= 0)
    }
}
>>>
object a {
  val select = if (max) { (a: CTuple, b: CTuple) =>
    (a.compareTo(b) >= 0)
  } else { (a: CTuple, b: CTuple) =>
    (a.compareTo(b) <= 0)
  }
}
<<< #1633 2.2: function block in a val statement
object a {
    val select = { (a: CTuple, b: CTuple) =>
      (a.compareTo(b) >= 0)
    }
}
>>>
object a {
  val select = { (a: CTuple, b: CTuple) =>
    (a.compareTo(b) >= 0)
  }
}
<<< #1633 3.1: function block
object a {
  b getOrElse { c(d) }
}
>>>
object a {
  b getOrElse c(d)
}
<<< #1633 3.2: function block
object a {
  b getOrElse { c.d {e} }
}
>>>
object a {
  b getOrElse c.d(e)
}
<<< #1633 3.3: function block in a val statement
object a {
  b getOrElse { c }
}
>>>
object a {
  b getOrElse c
}
<<< #1633 3.4: function block in a val statement
object a {
  b map { _.select }
}
>>>
object a {
  b map { _.select }
}
<<< #1633 3.5: function block in a val statement
object a {
  b map { _.apply(_) }
}
>>>
object a {
  b map { _.apply(_) }
}
<<< #1633 4.1: infix with literal
object a {
  1 + {
    2
  } + 3
}
>>>
object a {
  1 + 2 + 3
}
<<< #1633 4.2: infix with literal and no break before
object a {
  1 + {
    2  } + 3
}
>>>
object a {
  1 + 2 + 3
}
<<< #1633 4.3: infix with literal and comment
object a {
  1 + {
    2 // comment
  } + 3
}
>>>
object a {
  1 + {
    2 // comment
  } + 3
}
<<< #1633 4.4: infix with literal and two comments
object a {
  1 + {
    2 // comment
  } + // comment
   3
}
>>>
object a {
  1 + {
    2 // comment
  } + // comment
    3
}
<<< #1633 4.5: infix with apply
object a {
  1 + {
    a(b)
  } + 3
}
>>>
object a {
  1 + a(b) + 3
}
<<< #1633 4.6: infix with apply and no break before
object a {
  1 + {
    a(b)  } + 3
}
>>>
object a {
  1 + a(b) + 3
}
<<< #1633 4.7: infix with apply and comment
object a {
  1 + {
    a(b) // comment
  } + 3
}
>>>
object a {
  1 + {
    a(b) // comment
  } + 3
}
<<< #1633 4.8: infix with apply and two comments
object a {
  1 + {
    a(b) // comment
  } + // comment
   3
}
>>>
object a {
  1 + {
    a(b) // comment
  } + // comment
    3
}
<<< #1633 5.1: verify correct newline removal
newlines.afterCurlyLambda=squash
===
object a {
  val b = c(d => {
    e } // comment1
    /* comment2 */ )
    /* comment3 */
}
>>>
object a {
  val b = c(d => e) // comment1
  /* comment2 */
  /* comment3 */
}
<<< #1633 5.2: keep config style
object a {
  val b = c(
    d,
    e => {
     f }
  )
}
>>>
object a {
  val b = c(
    d,
    e => f
  )
}
<<< apply 1: single-stat block as an apply arg
rewrite.redundantBraces.methodBodies = false
===
object a {
  b({ 1 + 2 },
    { x => { y; z }})({ x => y }, { x; y })
}
>>>
object a {
  b(1 + 2, x => { y; z })(x => y, { x; y })
}
<<< apply 2: single-stat block as an apply arg
rewrite.redundantBraces.methodBodies = true
===
object a {
  b({ 1 + 2 },
    { x => { y; z }})({ x => y }, { x; y })
}
>>>
object a {
  b(1 + 2, { x => y; z })(x => y, { x; y })
}
<<< #1888 nested partial function
rewrite.redundantBraces { maxLines = 10, methodBodies = true }
===
function { implicit c =>
  {
    case bar => foo
  }
}
>>>
function { implicit c =>
  { case bar =>
    foo
  }
}
<<< #1888 nested partial function in parens
rewrite.redundantBraces { maxLines = 10, methodBodies = true }
===
object a {
  function(c => {
    case bar => foo
  })
}
>>>
object a {
  function(c => { case bar =>
    foo
  })
}
<<< try with partially enclosed 1: paren kept
object a {
  try { (x).y } catch { case a => }
  try { (x).y } catch handler
}
>>>
object a {
  try { (x).y }
  catch { case a => }
  try { (x).y }
  catch handler
}
<<< try with partially enclosed 2: paren removed
rewrite.rules = [RedundantBraces, RedundantParens]
===
object a {
  try { (x).y } catch { case a => }
  try { (x).y } catch handler
}
>>>
object a {
  try x.y
  catch { case a => }
  try x.y
  catch handler
}
<<< try with partially enclosed 3: brace kept
object a {
  try { {x + y}.z } catch { case a => }
  try { {x + y}.y } catch handler
}
>>>
object a {
  try { { x + y }.z }
  catch { case a => }
  try { { x + y }.y }
  catch handler
}
<<< try with partially enclosed 4: brace removed
object a {
  try { {x}.z } catch { case a => }
  try { {x}.y } catch handler
}
>>>
object a {
  try x.z
  catch { case a => }
  try x.y
  catch handler
}
<<< #1953
object a {
  scalacOptions ~= { _ filterNot (_ startsWith "-Xlint") }
}
>>>
object a {
  scalacOptions ~= { _ filterNot (_ startsWith "-Xlint") }
}
<<< #2012
rewrite.redundantBraces.generalExpressions = true
===
object Issue {
  def f(): Int = ???

  try {} finally {
    val _ = f()
  }
}
>>>
object Issue {
  def f(): Int = ???

  try {} finally {
    val _ = f()
  }
}
<<< #2117 maintain delimiter after removing newline in infix
1 op1{
2
}op2 3
>>>
1 op1 2 op2 3
<<< #2197 keep block around match expr
preset = default
rewrite.rules = [RedundantBraces]
===
object a {
  val result = {
    for {
      b <- o
    } yield b
  } match {
    case x => x
  }
}
>>>
object a {
  val result = {
    for {
      b <- o
    } yield b
  } match {
    case x => x
  }
}
<<< #2197 remove block around match expr
preset = default
rewrite.rules = [RedundantBraces]
===
object a {
  val result = {
    b(o)
  } match {
    case x => x
  }
}
>>>
object a {
  val result =
    b(o) match {
      case x => x
    }
}
<<< infix with new
object a {
  1 + {
    new A("a")
  } + 2
}
>>>
object a {
  1 + new A("a") + 2
}
<<< infix with new and select
object a {
  1 + {
    new A("a").run { "b" }
  } + 2
}
>>>
object a {
  1 + new A("a").run("b") + 2
}
<<< infix with new anonymous
object a {
  1 + {
    new A { def toString = "a" }
  } + 2
}
>>>
object a {
  1 + new A { def toString = "a" } + 2
}
<<< infix with new anonymous and select
object a {
  1 + {
    new A { def toString = "a" }.run { "b" }
  } + 2
}
>>>
object a {
  1 + new A { def toString = "a" }.run("b") + 2
}
<<< #2296
object a {
  val res = {new A}
  val res = {new A}.foo
  val res = {new A {}}
  val res = {new A {}}.foo
  val res = {new A with B}
  val res = {new A with B}.foo
  val res = {new A with B {}}
  val res = {new A with B {}}.foo
  val res = {new A { val foo = 1}}
  val res = {new A { val foo = 1}}.foo
  val res = {new A with B { val foo = 1}}
  val res = {new A with B { val foo = 1}}.foo
}
>>>
object a {
  val res = new A
  val res = new A.foo
  val res = new A {}
  val res = new A {}.foo
  val res = new A with B
  val res = { new A with B }.foo
  val res = new A with B {}
  val res = new A with B {}.foo
  val res = new A { val foo = 1 }
  val res = new A { val foo = 1 }.foo
  val res = new A with B { val foo = 1 }
  val res = new A with B { val foo = 1 }.foo
}
<<< #2426 placeholder in infix
def main(args: Array[String]): Unit =
  args foreach {
    println(_)
  }
>>>
def main(args: Array[String]): Unit =
  args foreach {
    println(_)
  }
<<< import simple
import x.{Y}
>>>
import x.Y
<<< import wildcard
import x.{_}
>>>
import x._
<<< import wildcard Scala 3
import x.{*}
>>>
import x.*
<<< import rename Scala 3
runner.dialect = Scala3
===
import x.{Y as Z}
>>>
import x.Y as Z
<<< import multiple wildcard untouched
import x.{Y, _}
>>>
import x.{Y, _}
<<< import multiple statements untouched
import x.{Y, Z}
>>>
import x.{Y, Z}
<<< import single statement without braces untouched
import x.Y
>>>
import x.Y
<<< import rename untouched
import x.{Y => Z}
>>>
import x.{Y => Z}
<<< import unimport untouched
import x.{Y => _}
>>>
import x.{Y => _}
<<< don't rewrite on disabled flag
rewrite.rules = []
===
import x.{Y}
>>>
import x.{Y}
<<< #2539 nested blocks
object a {
  def foo = {
    foo.map(foo => {{
      logger.info(logMarker, s"SomeFoo: $foo")
      foo
    }})
  }
}
>>>
object a {
  def foo = {
    foo.map { foo =>
      logger.info(logMarker, s"SomeFoo: $foo")
      foo
    }
  }
}
<<< #2539 nested rewritten lambda within another lambda
object ScalaFmtTest {
  foo.map(
    foo => foo(foo, 2)
      .map(bar => {
        baz
        bar
      })
  )
}
>>>
object ScalaFmtTest {
  foo.map(foo =>
    foo(foo, 2)
      .map { bar =>
        baz
        bar
      }
  )
}
<<< single-block function with block one-arg apply
object a {
  val foo = bar {
    { x => y }
  }
  val foo = bar {
    { { x => y } }
  }
  val foo = bar.baz {
    { x => y }
  }
  val foo = bar.baz {
    { { x => y } }
  }
}
>>>
object a {
  val foo = bar { x =>
    y
  }
  val foo = bar { x =>
    y
  }
  val foo = bar.baz { x =>
    y
  }
  val foo = bar.baz { x =>
    y
  }
}
<<< single-block partial function with parens one-arg apply
object a {
  val foo = bar (
    { case x => y }
  )
  val foo = bar (
    { { case x => y } }
  )
  val foo = bar (
    { { { case x => y } } }
  )
  val foo = bar.baz (
    { case x => y }
  )
  val foo = bar.baz (
    { { case x => y } }
  )
  val foo = bar.baz (
    { { { case x => y } } }
  )
}
>>>
object a {
  val foo = bar { case x => y }
  val foo = bar { case x => y }
  val foo = bar { case x => y }
  val foo = bar.baz { case x => y }
  val foo = bar.baz { case x => y }
  val foo = bar.baz { case x => y }
}
<<< single-block partial function with block one-arg apply
object a {
  val foo = bar {
    { case x => y }
  }
  val foo = bar {
    { { case x => y } }
  }
  val foo = bar {
    { { { case x => y } } }
  }
  val foo = bar.baz {
    { case x => y }
  }
  val foo = bar.baz {
    { { case x => y } }
  }
  val foo = bar.baz {
    { { { case x => y } } }
  }
}
>>>
object a {
  val foo = bar { case x =>
    y
  }
  val foo = bar { case x =>
    y
  }
  val foo = bar { case x =>
    y
  }
  val foo = bar.baz { case x =>
    y
  }
  val foo = bar.baz { case x =>
    y
  }
  val foo = bar.baz { case x =>
    y
  }
}
<<< init-only secondary ctors
class a(vi: Int, vs: String) {
  def this() = {

    this(0, "")

  }
  def this(vi: Int) = {
    this(vi, "")
  }
}
>>>
class a(vi: Int, vs: String) {
  def this() =
    this(0, "")

  def this(vi: Int) =
    this(vi, "")
}
<<< procedure-style secondary ctors
class a(vi: Int, vs: String) {
  def this() {

    this(0, "")

  }
  def this(vi: Int) {
    this(vi, "")
  }
}
>>>
class a(vi: Int, vs: String) {
  def this() =
    this(0, "")

  def this(vi: Int) =
    this(vi, "")
}
<<< procedure-style method
class a(vi: Int, vs: String) {
  def foo() {

    bar

  }
  def foo(vi: Int) {
    bar(vi, "")
  }
}
>>>
class a(vi: Int, vs: String) {
  def foo() {

    bar

  }
  def foo(vi: Int) {
    bar(vi, "")
  }
}
<<< #3026 defnBodies all
rewrite.redundantBraces.defnBodies = all
===
object a {
  var foo = {
    bar
  }
  val foo = {
    bar
  }
  def foo = {
    bar
  }
  def foo() = {
    bar
  }
  def foo(a: Int) = {
    bar
  }
  def foo = macro {
    bar
  }
  def foo() = macro {
    bar
  }
  def foo(a: Int) = macro {
    bar
  }
}
>>>
object a {
  var foo =
    bar
  val foo =
    bar
  def foo =
    bar
  def foo() =
    bar
  def foo(a: Int) =
    bar
  def foo = macro bar
  def foo() = macro bar
  def foo(a: Int) = macro bar
}
<<< #3026 defnBodies none
rewrite.redundantBraces.defnBodies = none
===
object a {
  var foo = {
    bar
  }
  val foo = {
    bar
  }
  def foo = {
    bar
  }
  def foo() = {
    bar
  }
  def foo(a: Int) = {
    bar
  }
  def foo = macro {
    bar
  }
  def foo() = macro {
    bar
  }
  def foo(a: Int) = macro {
    bar
  }
}
>>>
object a {
  var foo = {
    bar
  }
  val foo = {
    bar
  }
  def foo = {
    bar
  }
  def foo() = {
    bar
  }
  def foo(a: Int) = {
    bar
  }
  def foo = macro {
    bar
  }
  def foo() = macro {
    bar
  }
  def foo(a: Int) = macro {
    bar
  }
}
<<< #3026 defnBodies noParams
rewrite.redundantBraces.defnBodies = noParams
===
object a {
  var foo = {
    bar
  }
  val foo = {
    bar
  }
  def foo = {
    bar
  }
  def foo() = {
    bar
  }
  def foo(a: Int) = {
    bar
  }
  def foo = macro {
    bar
  }
  def foo() = macro {
    bar
  }
  def foo(a: Int) = macro {
    bar
  }
}
>>>
object a {
  var foo =
    bar
  val foo =
    bar
  def foo =
    bar
  def foo() = {
    bar
  }
  def foo(a: Int) = {
    bar
  }
  def foo = macro bar
  def foo() = macro {
    bar
  }
  def foo(a: Int) = macro {
    bar
  }
}
<<< #3263 assign value to var, use as arg
object a {
  foo({ bar = baz })
  foo({ bar = baz }, qux)
}
>>>
object a {
  foo({ bar = baz })
  foo({ bar = baz }, qux)
}
<<< #3296
preset = default
runner.dialect = scala3
rewrite.rules = [RedundantBraces]
rewrite.scala3.removeOptionalBraces = true
===
object A {
  implicit def map: Array[Any] => List[String] = a =>
    a.map (ae => {
      ae match
        case s: String => s
        case _ => ae.toString
    }).toList
}
>>>
object A:
  implicit def map: Array[Any] => List[String] = a =>
    a.map { ae =>
      ae match
        case s: String => s
        case _         => ae.toString
    }.toList
<<< #3540
object Bar extends Foo[(Int, String)]({ case (i, s) => () })
>>>
object Bar extends Foo[(Int, String)]({ case (i, s) => () })
<<< rewrite with trailing commas: block simple, allowFolding
rewrite.trailingCommas.style = keep
rewrite.trailingCommas.allowFolding = true
===
foo.mtd({
    x + 1
    x + 2
  },
)
>>>
foo.mtd({
  x + 1
  x + 2
})
<<< rewrite with trailing commas: block simple, !allowFolding
rewrite.trailingCommas.style = keep
rewrite.trailingCommas.allowFolding = false
===
foo.mtd({
    x + 1
    x + 2
  },
)
>>>
foo.mtd({
    x + 1
    x + 2
  },
)
<<< rewrite with trailing commas: func, allowFolding
rewrite.trailingCommas.style = keep
rewrite.trailingCommas.allowFolding = true
===
foo.mtd1({ x =>
    x + 1
    x + 2
  },
)
>>>
foo.mtd1({ x =>
  x + 1
  x + 2
})
<<< rewrite with trailing commas: func, !allowFolding
rewrite.trailingCommas.style = keep
rewrite.trailingCommas.allowFolding = false
===
foo.mtd1({ x =>
    x + 1
    x + 2
  },
)
>>>
foo.mtd1({ x =>
    x + 1
    x + 2
  },
)
<<< rewrite with trailing commas: func in parens, infix after, allowFolding
rewrite.trailingCommas.style = keep
rewrite.trailingCommas.allowFolding = true
===
object a {
  mtd1(
    x => {
      x + 1
    },
  ) + mtd2(
    x => {
      x + 1
      x + 2
    },
  )
}
>>>
object a {
  mtd1 { x =>
    x + 1
  } + mtd2 { x =>
    x + 1
    x + 2
  }
}
<<< rewrite with trailing commas: func in parens, infix after, !allowFolding
rewrite.trailingCommas.style = keep
rewrite.trailingCommas.allowFolding = false
===
object a {
  mtd1(
    x => {
      x + 1
    },
  ) + mtd2(
    x => {
      x + 1
      x + 2
    },
  )
}
>>>
object a {
  mtd1 { x =>
    x + 1
  } + mtd2 { x =>
    x + 1
    x + 2
  }
}
<<< rewrite with trailing commas: func in parens and braces, allowFolding
rewrite.rules = [RedundantBraces, RedundantParens]
rewrite.trailingCommas.style = keep
rewrite.trailingCommas.allowFolding = true
===
foo.mtd(
    { x =>
      x + 1
      x + 2
    },
  )
>>>
foo.mtd(
  { x =>
    x + 1
    x + 2
  },
)
<<< rewrite with trailing commas: func in parens and braces, !allowFolding
rewrite.rules = [RedundantBraces, RedundantParens]
rewrite.trailingCommas.style = keep
rewrite.trailingCommas.allowFolding = false
===
foo.mtd(
    { x =>
      x + 1
      x + 2
    },
  )
>>>
foo.mtd(
  { x =>
    x + 1
    x + 2
  },
)
<<< rewrite with trailing commas: func in parens and braces, infix after, allowFolding
rewrite.rules = [RedundantBraces, RedundantParens]
rewrite.trailingCommas.style = keep
rewrite.trailingCommas.allowFolding = true
===
object a {
  mtd1(
    { x =>
      x + 1
    },
  ) + mtd2(
    { x =>
      x + 1
      x + 2
    },
  ) + mtd3(
    { x =>
      x + 1
      x + 2
      x + 3
    },
  )
}
>>>
object a {
  mtd1(
    { x =>
      x + 1
    },
  ) + mtd2(
    { x =>
      x + 1
      x + 2
    },
  ) + mtd3(
    { x =>
      x + 1
      x + 2
      x + 3
    },
  )
}
<<< rewrite with trailing commas: func in parens and braces, infix after, !allowFolding
rewrite.rules = [RedundantBraces, RedundantParens]
rewrite.trailingCommas.style = keep
rewrite.trailingCommas.allowFolding = false
===
object a {
  mtd1(
    { x =>
      x + 1
    },
  ) + mtd2(
    { x =>
      x + 1
      x + 2
    },
  ) + mtd3(
    { x =>
      x + 1
      x + 2
      x + 3
    },
  )
}
>>>
object a {
  mtd1(
    { x =>
      x + 1
    },
  ) + mtd2(
    { x =>
      x + 1
      x + 2
    },
  ) + mtd3(
    { x =>
      x + 1
      x + 2
      x + 3
    },
  )
}
<<< rewrite with trailing commas: partial func, allowFolding
rewrite.trailingCommas.style = keep
rewrite.trailingCommas.allowFolding = true
===
foo.mtd({
    case x => x + 1
    case y => y + 1
  },
)
>>>
foo.mtd {
  case x => x + 1
  case y => y + 1
}
<<< rewrite with trailing commas: partial func, !allowFolding
rewrite.trailingCommas.style = keep
rewrite.trailingCommas.allowFolding = false
===
foo.mtd({
    case x => x + 1
    case y => y + 1
  },
)
>>>
foo.mtd {
  case x => x + 1
  case y => y + 1
}
<<< rewrite with trailing commas: match, allowFolding
rewrite.trailingCommas.style = keep
rewrite.trailingCommas.allowFolding = true
===
foo.mtd({
    bar match {
      case x => x + 1
    }
  },
)
>>>
foo.mtd({
  bar match {
    case x => x + 1
  }
})
<<< rewrite with trailing commas: match, !allowFolding
rewrite.trailingCommas.style = keep
rewrite.trailingCommas.allowFolding = false
===
foo.mtd({
    bar match {
      case x => x + 1
    }
  },
)
>>>
foo.mtd({
    bar match {
      case x => x + 1
    }
  },
)