Merge pull request #9095 from dotty-staging/throws-annot-3

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._
@@ -368,14 +368,12 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
             case StringTag =>
               assert(const.value != null, const) // TODO this invariant isn't documented in `case class Constant`
               av.visit(name, const.stringValue) // `stringValue` special-cases null, but that execution path isn't exercised for a const with StringTag
-            case ClazzTag => av.visit(name, typeToTypeKind(const.typeValue)(bcodeStore)(innerClasesStore).toASMType)
+            case ClazzTag => av.visit(name, typeToTypeKind(TypeErasure.erasure(const.typeValue))(bcodeStore)(innerClasesStore).toASMType)
             case EnumTag =>
               val edesc = innerClasesStore.typeDescriptor(const.tpe) // the class descriptor of the enumeration class.
               val evalue = const.symbolValue.javaSimpleName // value the actual enumeration value.
               av.visitEnum(name, edesc, evalue)
           }
-        case t: TypeApply if (t.fun.symbol == defn.Predef_classOf) =>
-          av.visit(name, typeToTypeKind(t.args.head.tpe.classSymbol.denot.info)(bcodeStore)(innerClasesStore).toASMType)
         case Ident(nme.WILDCARD) =>
           // An underscore argument indicates that we want to use the default value for this parameter, so do not emit anything
         case t: tpd.RefTree if t.symbol.denot.owner.isAllOf(JavaEnumTrait) =>
@@ -514,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)
@@ -614,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/Compiler.scala

@@ -68,7 +68,6 @@ class Compiler {
          new CacheAliasImplicits,    // Cache RHS of parameterless alias implicits
          new ByNameClosures,         // Expand arguments to by-name parameters to closures
          new HoistSuperArgs,         // Hoist complex arguments of supercalls to enclosing scope
-         new ClassOf,                // Expand `Predef.classOf` calls.
          new RefChecks) ::           // Various checks mostly related to abstract members and overriding
     List(new ElimOpaque,             // Turn opaque into normal aliases
          new TryCatchPatterns,       // Compile cases in try/catch
@@ -109,8 +108,7 @@ class Compiler {
     List(new Constructors,           // Collect initialization code in primary constructors
                                         // Note: constructors changes decls in transformTemplate, no InfoTransformers should be added after it
          new FunctionalInterfaces,   // Rewrites closures to implement @specialized types of Functions.
-         new Instrumentation,        // Count closure allocations under -Yinstrument-closures
-         new GetClass) ::            // Rewrites getClass calls on primitive types.
+         new Instrumentation) ::     // Count closure allocations under -Yinstrument-closures
     List(new LinkScala2Impls,        // Redirect calls to trait methods defined by Scala 2.x, so that they now go to
          new LambdaLift,             // Lifts out nested functions to class scope, storing free variables in environments
                                      // Note: in this mini-phase block scopes are incorrect. No phases that rely on scopes should be here

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -460,7 +460,19 @@ object desugar {
         case tree: MemberDef => Ident(tree.name.toTermName) :: Nil
         case PatDef(_, ids: List[Ident] @ unchecked, _, _) => ids
       }
-      val stats = impl.body.map(expandConstructor)
+
+      val stats0 = impl.body.map(expandConstructor)
+      val stats =
+        if (ctx.owner eq defn.ScalaPackageClass) && defn.hasProblematicGetClass(className) then
+          stats0.filterConserve {
+            case ddef: DefDef =>
+              ddef.name ne nme.getClass_
+            case _ =>
+              true
+          }
+        else
+          stats0
+
       if (isEnum) {
         val (enumCases, enumStats) = stats.partition(DesugarEnums.isEnumCase)
         if (enumCases.isEmpty)

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -9,6 +9,7 @@ import typer.ConstFold
 import reporting.trace
 import dotty.tools.dotc.transform.SymUtils._
 import Decorators._
+import Constants.Constant
 
 import scala.annotation.tailrec
 
@@ -396,7 +397,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     case New(_) | Closure(_, _, _) =>
       Pure
     case TypeApply(fn, _) =>
-      if (fn.symbol.is(Erased) || fn.symbol == defn.InternalQuoted_typeQuote) Pure else exprPurity(fn)
+      if (fn.symbol.is(Erased) || fn.symbol == defn.InternalQuoted_typeQuote || fn.symbol == defn.Predef_classOf) Pure else exprPurity(fn)
     case Apply(fn, args) =>
       def isKnownPureOp(sym: Symbol) =
         sym.owner.isPrimitiveValueClass
@@ -512,19 +513,35 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
    *
    *     { pre; v }
    *
+   *  (3) An expression `pre.getClass[..]()` that has a constant type `ConstantType(v)` but where
+   *  `pre` has side-effects is translated to:
+   *
+   *     { pre; v }
+   *
    *  This avoids the situation where we have a Select node that does not have a symbol.
    */
   def constToLiteral(tree: Tree)(implicit ctx: Context): Tree = {
     val tree1 = ConstFold(tree)
     tree1.tpe.widenTermRefExpr.dealias.normalized match {
+      case ConstantType(Constant(_: Type)) if tree.isInstanceOf[Block] =>
+        // We can't rewrite `{ class A; classOf[A] }` to `classOf[A]`, so we leave
+        // blocks returning a class literal alone, even if they're idempotent.
+        tree1
       case ConstantType(value) =>
         if (isIdempotentExpr(tree1)) Literal(value).withSpan(tree.span)
-        else tree1 match {
-          case Select(qual, _) if tree1.tpe.isInstanceOf[ConstantType] =>
-            // it's a primitive unary operator; Simplify `pre.op` to `{ pre; v }` where `v` is the value of `pre.op`
-            Block(qual :: Nil, Literal(value)).withSpan(tree.span)
-          case _ =>
-            tree1
+        else {
+          def keepPrefix(pre: Tree) =
+            Block(pre :: Nil, Literal(value)).withSpan(tree.span)
+
+          tree1 match {
+            case Select(pre, _) if tree1.tpe.isInstanceOf[ConstantType] =>
+              // it's a primitive unary operator; Simplify `pre.op` to `{ pre; v }` where `v` is the value of `pre.op`
+              keepPrefix(pre)
+            case Apply(TypeApply(Select(pre, nme.getClass_), _), Nil) =>
+              keepPrefix(pre)
+            case _ =>
+              tree1
+          }
         }
       case _ => tree1
     }

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -1154,25 +1154,24 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
   }
 
-  /** A tree that represents the class of the erasure of type `tp`. */
-  def clsOf(tp: Type)(implicit ctx: Context): Tree = {
-    def TYPE(module: TermSymbol) = ref(module).select(nme.TYPE_)
-    defn.scalaClassName(tp) match {
-      case tpnme.Boolean => TYPE(defn.BoxedBooleanModule)
-      case tpnme.Byte => TYPE(defn.BoxedByteModule)
-      case tpnme.Short => TYPE(defn.BoxedShortModule)
-      case tpnme.Char => TYPE(defn.BoxedCharModule)
-      case tpnme.Int => TYPE(defn.BoxedIntModule)
-      case tpnme.Long => TYPE(defn.BoxedLongModule)
-      case tpnme.Float => TYPE(defn.BoxedFloatModule)
-      case tpnme.Double => TYPE(defn.BoxedDoubleModule)
-      case tpnme.Unit => TYPE(defn.BoxedUnitModule)
-      case _ =>
-        if (ctx.erasedTypes || !tp.derivesFrom(defn.ArrayClass))
+  /** A tree that corresponds to `Predef.classOf[$tp]` in source */
+  def clsOf(tp: Type)(implicit ctx: Context): Tree =
+    if ctx.erasedTypes then
+      def TYPE(module: TermSymbol) = ref(module).select(nme.TYPE_)
+      defn.scalaClassName(tp) match
+        case tpnme.Boolean => TYPE(defn.BoxedBooleanModule)
+        case tpnme.Byte => TYPE(defn.BoxedByteModule)
+        case tpnme.Short => TYPE(defn.BoxedShortModule)
+        case tpnme.Char => TYPE(defn.BoxedCharModule)
+        case tpnme.Int => TYPE(defn.BoxedIntModule)
+        case tpnme.Long => TYPE(defn.BoxedLongModule)
+        case tpnme.Float => TYPE(defn.BoxedFloatModule)
+        case tpnme.Double => TYPE(defn.BoxedDoubleModule)
+        case tpnme.Unit => TYPE(defn.BoxedUnitModule)
+        case _ =>
           Literal(Constant(TypeErasure.erasure(tp)))
-        else Literal(Constant(tp))
-    }
-  }
+    else
+      Literal(Constant(tp))
 
   @tailrec
   def sameTypes(trees: List[tpd.Tree], trees1: List[tpd.Tree]): Boolean =

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/core/Definitions.scala

@@ -1309,6 +1309,27 @@ class Definitions {
     else parents
   }
 
+  private val HasProblematicGetClass: Set[Name] = Set(
+    tpnme.AnyVal, tpnme.Byte, tpnme.Short, tpnme.Char, tpnme.Int, tpnme.Long, tpnme.Float, tpnme.Double,
+    tpnme.Unit, tpnme.Boolean)
+
+  /** When typing a primitive value class or AnyVal, we ignore the `getClass`
+   *  member: it's supposed to be an override of the `getClass` defined on `Any`,
+   *  but in dotty `Any#getClass` is polymorphic so it ends up being an overload.
+   *  This is especially problematic because it means that when writing:
+   *
+   *    1.asInstanceOf[Int & AnyRef].getClass
+   *
+   *  the `getClass` that returns `Class[Int]` defined in Int can be selected,
+   *  but this call is specified to return `classOf[Integer]`, see
+   *  tests/run/t5568.scala.
+   *
+   *  FIXME: remove all the `getClass` methods defined in the standard library
+   *  so we don't have to hot-patch it like this.
+   */
+  def hasProblematicGetClass(className: Name): Boolean =
+    HasProblematicGetClass.contains(className)
+
   /** Is synthesized symbol with alphanumeric name allowed to be used as an infix operator? */
   def isInfix(sym: Symbol)(implicit ctx: Context): Boolean =
     (sym eq Object_eq) || (sym eq Object_ne)

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -187,11 +187,12 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
           val savedIndex = readIndex
           readIndex = index(i)
           val sym = readSymbol()
-          entries(i) = sym
-          sym.infoOrCompleter match {
-            case info: ClassUnpickler => info.init()
-            case _ =>
-          }
+          if sym.exists then
+            entries(i) = sym
+            sym.infoOrCompleter match {
+              case info: ClassUnpickler => info.init()
+              case _ =>
+            }
           readIndex = savedIndex
         }
         i += 1
@@ -438,6 +439,10 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
     var name = at(nameref, () => readName()(ctx))
     val owner = readSymbolRef()
 
+    if (name eq nme.getClass_) && defn.hasProblematicGetClass(owner.name) then
+      // skip this member
+      return NoSymbol
+
     var flags = unpickleScalaFlags(readLongNat(), name.isTypeName)
 
     name = name.adjustIfModuleClass(flags)