Fix #8593: Implement support for @throws

The implementation and tests are based on the scalac implementation, the
implementation relies on the classOf rewrite in the previous commit.

Author: smarter

compiler/src/dotty/tools/backend/jvm/BCodeHelpers.scala

@@ -11,7 +11,7 @@ import scala.collection.mutable
 import dotty.tools.dotc.CompilationUnit
 import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.ast.Trees
-import dotty.tools.dotc.core.Annotations.Annotation
+import dotty.tools.dotc.core.Annotations._
 import dotty.tools.dotc.core.Constants._
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Decorators._
@@ -512,7 +512,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
 
       // TODO needed? for(ann <- m.annotations) { ann.symbol.initialize }
       val jgensig = getStaticForwarderGenericSignature(m, module)
-      val (throws, others) = m.annotations partition (_.tree.symbol == defn.ThrowsAnnot)
+      val (throws, others) = m.annotations.partition(_.symbol eq defn.ThrowsAnnot)
       val thrownExceptions: List[String] = getExceptions(throws)
 
       val jReturnType = toTypeKind(methodInfo.resultType)
@@ -612,12 +612,9 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
      * must-single-thread
      */
     def getExceptions(excs: List[Annotation]): List[String] = {
-      // TODO: implement ThrownException
-      // for (ThrownException(exc) <- excs.distinct)
-      // yield internalName(exc)
-      Nil
+      for (case ThrownException(exc) <- excs.distinct)
+      yield internalName(TypeErasure.erasure(exc).classSymbol)
     }
-
   } // end of trait BCForwardersGen
 
   trait BCClassGen extends BCInnerClassGen {

compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala

@@ -513,7 +513,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
     def initJMethod(flags: Int, paramAnnotations: List[List[Annotation]]): Unit = {
 
       val jgensig = getGenericSignature(methSymbol, claszSymbol)
-      val (excs, others) = methSymbol.annotations partition (_.tree.symbol == defn.ThrowsAnnot)
+      val (excs, others) = methSymbol.annotations.partition(_.symbol eq defn.ThrowsAnnot)
       val thrownExceptions: List[String] = getExceptions(excs)
 
       val bytecodeName =

compiler/src/dotty/tools/dotc/core/Annotations.scala

@@ -235,4 +235,28 @@ object Annotations {
       }
       yield ScalaVersion.parse(arg.stringValue)
   }
+
+  /** Extracts the type of the thrown exception from an annotation.
+   *
+   *  Supports both "old-style" `@throws(classOf[Exception])`
+   *  as well as "new-style" `@throws[Exception]("cause")` annotations.
+   */
+  object ThrownException {
+    def unapply(a: Annotation)(using Context): Option[Type] =
+      if (a.symbol ne defn.ThrowsAnnot)
+        None
+      else a.argumentConstant(0) match {
+        // old-style: @throws(classOf[Exception]) (which is throws[T](classOf[Exception]))
+        case Some(Constant(tpe: Type)) =>
+          Some(tpe)
+        // new-style: @throws[Exception], @throws[Exception]("cause")
+        case _ =>
+          stripApply(a.tree) match {
+            case TypeApply(_, List(tpt)) =>
+              Some(tpt.tpe)
+            case _ =>
+              None
+          }
+      }
+  }
 }

compiler/src/dotty/tools/dotc/transform/GenericSignatures.scala

@@ -2,7 +2,7 @@ package dotty.tools
 package dotc
 package transform
 
-import core.Annotations.Annotation
+import core.Annotations._
 import core.Contexts.Context
 import core.Definitions
 import core.Flags._
@@ -381,21 +381,6 @@ object GenericSignatures {
         (initialSymbol.is(Method) && initialSymbol.typeParams.contains(sym))
       )
 
-  /** Extracts the type of the thrown exception from an AnnotationInfo.
-    *
-    * Supports both “old-style” `@throws(classOf[Exception])`
-    * as well as “new-style” `@throws[Exception]("cause")` annotations.
-    */
-  private object ThrownException {
-    def unapply(ann: Annotation)(implicit ctx: Context): Option[Type] =
-      ann.tree match {
-        case Apply(TypeApply(fun, List(tpe)), _) if tpe.isType && fun.symbol.owner == defn.ThrowsAnnot && fun.symbol.isConstructor =>
-          Some(tpe.typeOpt)
-        case _ =>
-          None
-      }
-  }
-
   // @M #2585 when generating a java generic signature that includes
   // a selection of an inner class p.I, (p = `pre`, I = `cls`) must
   // rewrite to p'.I, where p' refers to the class that directly defines

tests/run/t6380.check

@@ -0,0 +1,7 @@
+List(class java.lang.Exception)
+List(class java.lang.Throwable)
+List(class java.lang.RuntimeException)
+List(class java.lang.IllegalArgumentException, class java.util.NoSuchElementException)
+List(class java.lang.IndexOutOfBoundsException, class java.lang.IndexOutOfBoundsException)
+List(class java.lang.IllegalStateException, class java.lang.IllegalStateException)
+List(class java.lang.NullPointerException, class java.lang.NullPointerException)

tests/run/t6380.scala

@@ -0,0 +1,20 @@
+object Test extends App {
+  classOf[Foo].getDeclaredMethods().sortBy(_.getName).map(_.getExceptionTypes.sortBy(_.getName).toList).toList.foreach(println)
+}
+
+class Foo {
+  @throws[Exception]
+  def bar1 = ???
+  @throws[Throwable]("always")
+  def bar2 = ???
+  @throws(classOf[RuntimeException])
+  def bar3 = ???
+  @throws[IllegalArgumentException] @throws[NoSuchElementException]
+  def bar4 = ???
+  @throws(classOf[IndexOutOfBoundsException]) @throws(classOf[IndexOutOfBoundsException])
+  def bar5 = ???
+  @throws[IllegalStateException]("Cause") @throws[IllegalStateException]
+  def bar6 = ???
+  @throws[NullPointerException]("Cause A") @throws[NullPointerException]("Cause B")
+  def bar7 = ???
+}

tests/run/throws-annot.check

@@ -0,0 +1,21 @@
+read throws: class java.io.IOException
+read annotations: 
+readWith2 throws: class java.io.IOException, class java.lang.ClassCastException
+readWith2 annotations: 
+readMixed throws: class java.lang.NullPointerException, class java.io.IOException
+readMixed annotations: interface java.lang.Deprecated
+readMixed2 throws: class java.lang.NullPointerException, class java.io.IOException
+readMixed2 annotations: interface java.lang.Deprecated
+readNoEx throws: 
+readNoEx annotations: interface java.lang.Deprecated
+Testing mirror class
+read throws: class java.io.IOException
+read annotations: 
+readWith2 throws: class java.io.IOException, class java.lang.ClassCastException
+readWith2 annotations: 
+readMixed throws: class java.lang.NullPointerException, class java.io.IOException
+readMixed annotations: interface java.lang.Deprecated
+readMixed2 throws: class java.lang.NullPointerException, class java.io.IOException
+readMixed2 annotations: interface java.lang.Deprecated
+readNoEx throws: 
+readNoEx annotations: interface java.lang.Deprecated

tests/run/throws-annot.scala

@@ -0,0 +1,75 @@
+/** Test the @throws annotation */
+import java.io.IOException
+
+object TestThrows {
+
+  abstract class Foo {
+
+    @throws(classOf[IOException])
+    def read(): Int
+
+    @throws(classOf[ClassCastException])
+    @throws(classOf[IOException])
+    def readWith2(): Int
+
+    @throws(classOf[IOException])
+    @Deprecated
+    @throws(classOf[NullPointerException])
+    def readMixed(): Int
+
+    @Deprecated
+    @throws(classOf[IOException])
+    @throws(classOf[NullPointerException])
+    def readMixed2(): Int
+
+    @Deprecated
+    def readNoEx(): Int
+  }
+
+  def checkMethod(cls: Class[_], name: String): Unit = {
+    val method = cls.getMethod(name)
+    println(name + " throws: " + method.getExceptionTypes.mkString("", ", ", ""))
+    val annots = method.getDeclaredAnnotations.map(_.annotationType)
+    println(name + " annotations: " + annots.mkString("", ", ", ""))
+  }
+
+  def run(cls: Class[_]): Unit = {
+    checkMethod(cls, "read")
+    checkMethod(cls, "readWith2")
+    checkMethod(cls, "readMixed")
+    checkMethod(cls, "readMixed2")
+    checkMethod(cls, "readNoEx")
+  }
+}
+
+/** Test the top-level mirror that is has the annotations. */
+object TL {
+
+  @throws(classOf[IOException])
+  def read(): Int = 0
+
+  @throws(classOf[ClassCastException])
+  @throws(classOf[IOException])
+  def readWith2(): Int = 0
+
+  @throws(classOf[IOException])
+  @Deprecated
+  @throws(classOf[NullPointerException])
+  def readMixed(): Int = 0
+
+  @Deprecated
+  @throws(classOf[IOException])
+  @throws(classOf[NullPointerException])
+  def readMixed2(): Int = 0
+
+  @Deprecated
+  def readNoEx(): Int = 0
+}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    TestThrows.run(classOf[TestThrows.Foo])
+    println("Testing mirror class")
+    TestThrows.run(Class.forName("TL"))
+  }
+}