Merge pull request scala#7409 from hepin1989/2.13.x

=lib Add return type for Exception#handling

Author: lrytz

src/library/scala/util/control/Exception.scala

@@ -154,19 +154,19 @@ import scala.language.implicitConversions
 object Exception {
   type Catcher[+T] = PartialFunction[Throwable, T]
 
-  def mkCatcher[Ex <: Throwable: ClassTag, T](isDef: Ex => Boolean, f: Ex => T) = new Catcher[T] {
+  def mkCatcher[Ex <: Throwable: ClassTag, T](isDef: Ex => Boolean, f: Ex => T): PartialFunction[Throwable, T] = new Catcher[T] {
     private def downcast(x: Throwable): Option[Ex] =
       if (classTag[Ex].runtimeClass.isAssignableFrom(x.getClass)) Some(x.asInstanceOf[Ex])
       else None
 
-    def isDefinedAt(x: Throwable) = downcast(x) exists isDef
+    def isDefinedAt(x: Throwable): Boolean = downcast(x) exists isDef
     def apply(x: Throwable): T = f(downcast(x).get)
   }
 
-  def mkThrowableCatcher[T](isDef: Throwable => Boolean, f: Throwable => T) = mkCatcher[Throwable, T](isDef, f)
+  def mkThrowableCatcher[T](isDef: Throwable => Boolean, f: Throwable => T): PartialFunction[Throwable, T] = mkCatcher[Throwable, T](isDef, f)
 
   implicit def throwableSubtypeToCatcher[Ex <: Throwable: ClassTag, T](pf: PartialFunction[Ex, T]): Catcher[T] =
-    mkCatcher(pf.isDefinedAt _, pf.apply _)
+    mkCatcher(pf.isDefinedAt, pf.apply)
 
   /** !!! Not at all sure of every factor which goes into this,
    *  and/or whether we need multiple standard variations.
@@ -182,12 +182,12 @@ object Exception {
   trait Described {
     protected val name: String
     private[this] var _desc: String = ""
-    def desc = _desc
+    def desc: String = _desc
     def withDesc(s: String): this.type = {
       _desc = s
       this
     }
-    override def toString() = name + "(" + desc + ")"
+    override def toString(): String = name + "(" + desc + ")"
   }
 
   /** A container class for finally code.
@@ -260,8 +260,8 @@ object Exception {
       * but with the supplied `apply` method replacing the current one. */
     def withApply[U](f: Throwable => U): Catch[U] = {
       val pf2 = new Catcher[U] {
-        def isDefinedAt(x: Throwable) = pf isDefinedAt x
-        def apply(x: Throwable) = f(x)
+        def isDefinedAt(x: Throwable): Boolean = pf isDefinedAt x
+        def apply(x: Throwable): U = f(x)
       }
       new Catch(pf2, fin, rethrow)
     }
@@ -344,10 +344,9 @@ object Exception {
     * }}}
     *  @group dsl
     */
-  // TODO: Add return type
-  def handling[T](exceptions: Class[_]*) = {
-    def fun(f: Throwable => T) = catching(exceptions: _*) withApply f
-    new By[Throwable => T, Catch[T]](fun _)
+  def handling[T](exceptions: Class[_]*): By[Throwable => T, Catch[T]] = {
+    def fun(f: Throwable => T): Catch[T] = catching(exceptions: _*) withApply f
+    new By[Throwable => T, Catch[T]](fun)
   }
 
   /** Returns a `Catch` object with no catch logic and the argument as the finally logic.