Router bugfix: find the correct lambda right arrow

When lambda parameters are themselves functions and contained arrows in their type definitions, the code would locate the wrong arrow and then fail to break after it as no such break is defined in any rules. Fixes #1714.
scalameta · Feb 17, 2020 · 2f3e215 · 2f3e215
1 parent 20d0f57
commit 2f3e215
Show file tree

Hide file tree

Showing 2 changed files with 97 additions and 1 deletion.
diff --git a/scalafmt-core/shared/src/main/scala/org/scalafmt/internal/Router.scala b/scalafmt-core/shared/src/main/scala/org/scalafmt/internal/Router.scala
@@ -191,7 +191,18 @@ class Router(formatOps: FormatOps) {
             .get(hash(right))
             .collect {
               case owner: Term.Function =>
-                val arrow = lastLambda(owner).tokens.find(_.is[T.RightArrow])
+                val lastFunc = lastLambda(owner)
+                // look for arrow before body, if any, else after params
+                val arrow = lastFunc.body.tokens.headOption
+                  .map(x => prevNonComment(tokens(x, -1)).left)
+                  .orElse {
+                    val lastParam = lastFunc.params.lastOption
+                    lastParam.flatMap(_.tokens.lastOption).map { x =>
+                      val beforeArrow = nextNonComment(tokens(x))
+                      if (beforeArrow.right.is[T.RightArrow]) beforeArrow.right
+                      else nextNonComment(tokens(beforeArrow, 1)).right
+                    }
+                  }
                 val expire = arrow.getOrElse(owner.params.last.tokens.last)
                 (expire, arrow, 0)
             }

diff --git a/scalafmt-tests/src/test/resources/default/Lambda.stat b/scalafmt-tests/src/test/resources/default/Lambda.stat
@@ -301,3 +301,88 @@ object a {
       |""".stripMargin
   }
 }
+<<< #1714 1
+testAsync("Resource.make is equivalent to a partially applied bracket") { implicit ec =>
+    check { (acquire: IO[String], release: String => IO[Unit], f: String => IO[String]) =>
+      acquire.bracket(f)(release) <-> Resource.make(acquire)(release).use(f)
+    }
+  }
+>>>
+testAsync("Resource.make is equivalent to a partially applied bracket") {
+  implicit ec =>
+    check {
+      (acquire: IO[String],
+       release: String => IO[Unit],
+       f: String => IO[String]) =>
+        acquire.bracket(f)(release) <-> Resource.make(acquire)(release).use(f)
+    }
+}
+<<< #1714 2
+align = none
+maxColumn = 120
+danglingParentheses = true
+===
+testAsync("Resource.make is equivalent to a partially applied bracket") { implicit ec =>
+    check { (acquire: IO[String], release: String => IO[Unit], f: String => IO[String]) =>
+      acquire.bracket(f)(release) <-> Resource.make(acquire)(release).use(f)
+    }
+  }
+>>>
+testAsync("Resource.make is equivalent to a partially applied bracket") { implicit ec =>
+  check { (acquire: IO[String], release: String => IO[Unit], f: String => IO[String]) =>
+    acquire.bracket(f)(release) <-> Resource.make(acquire)(release).use(f)
+  }
+}
+<<< #1714 3
+align = none
+maxColumn = 120
+danglingParentheses = true
+===
+testAsync("Resource.make is equivalent to a partially applied bracket") { implicit ec =>
+    check { (acquire: IO[String], release: String => IO[Unit], f: String => IO[String]/* c1 */)/* c2 */=>
+      /*c3*/ acquire.bracket(f)(release) <-> Resource.make(acquire)(release).use(f)
+    }
+  }
+>>>
+testAsync("Resource.make is equivalent to a partially applied bracket") { implicit ec =>
+  check { (acquire: IO[String], release: String => IO[Unit], f: String => IO[String] /* c1 */ ) /* c2 */ =>
+    /*c3*/
+    acquire.bracket(f)(release) <-> Resource.make(acquire)(release).use(f)
+  }
+}
+<<< #1714 4
+align = none
+maxColumn = 120
+danglingParentheses = true
+===
+testAsync("Resource.make is equivalent to a partially applied bracket") { implicit ec =>
+    check { (acquire: IO[String], release: String => IO[Unit], f: String => IO[String]/* c1 */)/* c2 */=>
+      /*c3*/ { acquire.bracket(f)(release) <-> Resource.make(acquire)(release).use(f) }
+    }
+  }
+>>>
+testAsync("Resource.make is equivalent to a partially applied bracket") { implicit ec =>
+  check { (acquire: IO[String], release: String => IO[Unit], f: String => IO[String] /* c1 */ ) /* c2 */ =>
+    /*c3*/
+    { acquire.bracket(f)(release) <-> Resource.make(acquire)(release).use(f) }
+  }
+}
+<<< #1714 5
+align = none
+maxColumn = 120
+danglingParentheses = true
+===
+testAsync("Resource.make is equivalent to a partially applied bracket") { implicit ec =>
+    check { (acquire: IO[String], release: String => IO[Unit], f: String => IO[String]/* c1 */)/* c2 */=>
+      { /*c3*/ acquire.bracket(f)(release) <-> Resource.make(acquire)(release).use(f) }
+    }
+  }
+>>>
+testAsync("Resource.make is equivalent to a partially applied bracket") { implicit ec =>
+  check { (acquire: IO[String], release: String => IO[Unit], f: String => IO[String] /* c1 */ ) /* c2 */ =>
+    {
+      /*c3*/
+      acquire.bracket(f)(release) <-> Resource.make(acquire)(release).use(f)
+    }
+  }
+}