Add modifier to symbol that doesn't have a return type

The compiler reports for

    def meth

and

    def meth: Unit

the same tree, especially the `TypeTree` are exactly the same. The only
way to find out if the document contains the return type or not is to do
a lookup to the file.

Fixes #1002221

Author: kiritsuku

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

@@ -977,7 +977,19 @@ trait ReusingPrinter extends TreePrintingTraversals with AbstractPrinter {
       }
 
       val body = p(rhs)
-      val resultType = p(tpt, before = Requisite.allowSurroundingWhitespace(":", ": "))
+
+      def existsTptInFile = tpt match {
+        case tpt: TypeTree =>
+          val textInFile = betweenStartAndEnd(tpt).asText
+          textInFile == tpt.toString() || textInFile == tpt.original.toString()
+        case _ => false
+      }
+
+      val resultType =
+        if (body == EmptyFragment && !existsTptInFile)
+          EmptyFragment
+        else
+          p(tpt, before = Requisite.allowSurroundingWhitespace(":", ": "))
 
       def hasEqualInSource = {
         val originalDefDef = orig(tree)

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

@@ -146,4 +146,57 @@ class ReusingPrinterTest extends TestHelper with SilentTracing {
           d.copy(mods = d.mods.withFlag(Flag.FINAL).withFlag(Flag.CASE).withFlag(Flag.PRIVATE)) replaces d
       }
     }}
+
+  @Test
+  def add_modifier_to_def_without_return_type() = """
+    trait T {
+      def meth: Int
+    }
+    trait TT extends T {
+      def meth
+    }
+    """ becomes """
+    trait T {
+      def meth: Int
+    }
+    trait TT extends T {
+      override def meth
+    }
+    """ after topdown { matchingChildren {
+      filter {
+        case d: DefDef =>
+          d.symbol.isOverridingSymbol && !d.symbol.isOverride
+      } &>
+      transform {
+        case d: DefDef =>
+          d.copy(mods = d.mods.withFlag(Flag.OVERRIDE)) replaces d
+      }
+    }}
+
+  @Test
+  def add_modifier_to_val_without_return_type() = """
+    trait T {
+      def meth: Int
+    }
+    trait TT extends T {
+      val meth
+    }
+    """ becomes """
+    trait T {
+      def meth: Int
+    }
+    trait TT extends T {
+      override val meth
+    }
+    """ after topdown { matchingChildren {
+      filter {
+        case d: ValDef =>
+          val getter = d.symbol.getter(d.symbol.owner)
+          getter.isOverridingSymbol && !getter.isOverride
+      } &>
+      transform {
+        case d: ValDef =>
+          d.copy(mods = d.mods.withFlag(Flag.OVERRIDE)) replaces d
+      }
+    }}
 }