Generate return type for defs with single expressions in braces

In case

    def foo = {
      0
    }

should be transformed to

    def foo: Int = {
      0
    }

by adding its return type, the result was

    def foo: Int = 0
    }

Fixes #1002268

Author: kiritsuku

org.scala-refactoring.library/src/main/scala/scala/tools/refactoring/sourcegen/ReusingPrinter.scala

@@ -921,10 +921,12 @@ trait ReusingPrinter extends TreePrintingTraversals with AbstractPrinter {
         val body = p(rhs)
         val noEqualNeeded = body == EmptyFragment || rhs.tpe == null || (rhs.tpe != null && rhs.tpe.toString == "Unit")
 
+        def openingBrace = keepOpeningBrace(tree, tpt, rhs)
+
         if (noEqualNeeded)
           l ++ mods_ ++ resultType ++ body ++ r
         else
-          l ++ mods_ ++ resultType ++ Requisite.anywhere("=", " = ") ++ body ++ r
+          l ++ mods_ ++ resultType ++ Requisite.anywhere("=", " = ") ++ openingBrace ++ body ++ r
       }
     }
 
@@ -1004,12 +1006,25 @@ trait ReusingPrinter extends TreePrintingTraversals with AbstractPrinter {
         body == EmptyFragment || rhs.tpe == null || (rhs.tpe != null && rhs.tpe.toString == "Unit")
       }
 
+      def openingBrace = keepOpeningBrace(tree, tpt, rhs)
+
       if (noEqualNeeded && !hasEqualInSource) {
         l ++ modsAndName ++ typeParameters ++ parameters ++ resultType ++ body ++ r
       } else {
-        l ++ modsAndName ++ typeParameters ++ parameters ++ resultType ++ Requisite.anywhere("=", " = ") ++ body ++ r
+        l ++ modsAndName ++ typeParameters ++ parameters ++ resultType ++ Requisite.anywhere("=", " = ") ++ openingBrace ++ body ++ r
       }
     }
+
+    private def keepOpeningBrace(tree: Tree, tpt: Tree, rhs: Tree): String = tpt match {
+      case tpt: TypeTree if tpt.original != null && tree.pos != NoPosition && rhs.pos != NoPosition =>
+        val OpeningBrace = "(?s).*(\\{.*)".r
+        Layout(tree.pos.source, tree.pos.point, rhs.pos.start).asText match {
+          case OpeningBrace(brace) => brace
+          case _ => ""
+        }
+      case _ =>
+        ""
+    }
   }
 
   trait SuperPrinters {

org.scala-refactoring.library/src/test/scala/scala/tools/refactoring/tests/sourcegen/ReusingPrinterTest.scala

@@ -91,6 +91,94 @@ class ReusingPrinterTest extends TestHelper with SilentTracing {
         d.copy(tpt = newTpt) replaces d
     }}}
 
+  @Test
+  def add_return_type_to_val_with_single_expression_in_braces() = """
+    package add_return_type_to_val_with_single_expression_in_braces
+    object X {
+      val foo = {
+        0
+      }
+    }
+    """ becomes """
+    package add_return_type_to_val_with_single_expression_in_braces
+    object X {
+      val foo: Int = {
+        0
+      }
+    }
+    """ after topdown { matchingChildren { transform {
+      case d @ ValDef(_, _, tpt: TypeTree, _) =>
+        val newTpt = tpt setOriginal mkReturn(List(tpt.tpe.typeSymbol))
+        d.copy(tpt = newTpt) replaces d
+    }}}
+
+  @Test
+  def add_return_type_to_val_with_multiple_expressions_in_braces() = """
+    package add_return_type_to_val_with_multiple_expressions_in_braces
+    object X {
+      val foo = {
+        val a = 0
+        a
+      }
+    }
+    """ becomes """
+    package add_return_type_to_val_with_multiple_expressions_in_braces
+    object X {
+      val foo: Int = {
+        val a: Int = 0
+        a
+      }
+    }
+    """ after topdown { matchingChildren { transform {
+      case d @ ValDef(_, _, tpt: TypeTree, _) =>
+        val newTpt = tpt setOriginal mkReturn(List(tpt.tpe.typeSymbol))
+        d.copy(tpt = newTpt) replaces d
+    }}}
+
+  @Test
+  def add_return_type_to_def_with_single_expression_in_braces() = """
+    package add_return_type_to_def_with_single_expression_in_braces
+    object X {
+      def foo = {
+        0
+      }
+    }
+    """ becomes """
+    package add_return_type_to_def_with_single_expression_in_braces
+    object X {
+      def foo: Int = {
+        0
+      }
+    }
+    """ after topdown { matchingChildren { transform {
+      case d @ DefDef(_, _, _, _, tpt: TypeTree, _) =>
+        val newTpt = tpt setOriginal mkReturn(List(tpt.tpe.typeSymbol))
+        d.copy(tpt = newTpt) replaces d
+    }}}
+
+  @Test
+  def add_return_type_to_def_with_multiple_expressions_in_braces() = """
+    package add_return_type_to_def_with_multiple_expressions_in_braces
+    object X {
+      def foo = {
+        def a = 0
+        a
+      }
+    }
+    """ becomes """
+    package add_return_type_to_def_with_multiple_expressions_in_braces
+    object X {
+      def foo: Int = {
+        def a: Int = 0
+        a
+      }
+    }
+    """ after topdown { matchingChildren { transform {
+      case d @ DefDef(_, _, _, _, tpt: TypeTree, _) =>
+        val newTpt = tpt setOriginal mkReturn(List(tpt.tpe.typeSymbol))
+        d.copy(tpt = newTpt) replaces d
+    }}}
+
   @Test
   def add_override_flag() = """
     package add_override_flag