Extra check to avoid converting block expressions on the rhs of an infix expression.

Tests added for:
* Original cast as per the ticket should not be changed
* Similar match statement that should update
* Code blocks in this position, as opposed to a partial function, cant update here
* Simple change that should apply but in a code position where the op stack is nonempty
* Equivalent code, but passing in the partial function as a single parameter, again, not updating

Author: Lucy Martin

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -814,6 +814,8 @@ object Parsers {
      *   6. the opening brace does not follow a `=>`. The reason for this condition is that
      *      rewriting back to braces does not work after `=>` (since in most cases braces are omitted
      *      after a `=>` it would be annoying if braces were inserted).
+     *   7. not a code block being the input to a direct function call `inst method {\n expr \n}` cannot become
+     *      `inst method :\n expr`
      */
     def bracesToIndented[T](body: => T, rewriteWithColon: Boolean): T = {
       val underColonSyntax = possibleColonOffset == in.lastOffset
@@ -827,10 +829,20 @@ object Parsers {
       }
       var canRewrite = allBraces(in.currentRegion) && // test (1)
         !testChars(in.lastOffset - 3, " =>") // test(6)
+
+      def isStartOfFunction: Boolean =
+        opStack.headOption.exists(x => x.offset > startOpening && x.offset < endOpening)
       val t = enclosed(LBRACE, {
         canRewrite &= in.isAfterLineEnd // test (2)
         val curOffset = in.offset
-        try body
+        try {
+          val bodyResolved = body
+          bodyResolved match
+            case x:(Match | Block) =>
+              canRewrite &= !isStartOfFunction // test (7)
+            case _ =>
+          bodyResolved
+        }
         finally {
           canRewrite &= in.isAfterLineEnd && in.offset != curOffset // test (3)(4)
         }

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -75,6 +75,7 @@ class CompilationTests {
       compileFile("tests/rewrites/i12340.scala", unindentOptions.and("-rewrite")),
       compileFile("tests/rewrites/i17187.scala", unindentOptions.and("-rewrite")),
       compileFile("tests/rewrites/i17399.scala", unindentOptions.and("-rewrite")),
+      compileFile("tests/rewrites/i20002.scala", defaultOptions.and("-indent", "-rewrite")),
     ).checkRewrites()
   }
 

tests/rewrites/i20002.check

@@ -0,0 +1,32 @@
+object Reactions:
+  def main: Unit =
+    Reactions += {
+      case 0 =>
+      case 1 =>
+    }
+
+    def bar: Int = ???
+
+    bar match
+      case 0 =>
+      case 1 =>
+
+    def partPartial(i: Int): PartialFunction[Int, Unit] =
+      case `i` =>
+
+    Reactions += {
+      val pp1 = partPartial(1)
+      val pp2 = partPartial(2)
+      def codeBlock =
+        ???
+        ???
+      pp1 orElse pp2
+    }
+
+    val partialFunction = partPartial(1) orElse partPartial(2)
+    Reactions += {
+      partialFunction
+    }
+  def +=(f: PartialFunction[Int, Unit]) =
+    ???
+

tests/rewrites/i20002.scala

@@ -0,0 +1,38 @@
+object Reactions {
+  def main: Unit = {
+    Reactions += {
+      case 0 =>
+      case 1 =>
+    }
+
+    def bar: Int = ???
+
+    bar match {
+      case 0 =>
+      case 1 =>
+    }
+
+    def partPartial(i: Int): PartialFunction[Int, Unit] = {
+      case `i` =>
+    }
+
+    Reactions += {
+      val pp1 = partPartial(1)
+      val pp2 = partPartial(2)
+      def codeBlock = {
+        ???
+        ???
+      }
+      pp1 orElse pp2
+    }
+
+    val partialFunction = partPartial(1) orElse partPartial(2)
+    Reactions += {
+      partialFunction
+    }
+  }
+  def +=(f: PartialFunction[Int, Unit]) = {
+    ???
+  }
+
+}