Add workaround for #22616

Author: mbovel

tests/pos-macros/i22616c/Macro_4.scala

@@ -0,0 +1,14 @@
+import scala.quoted.*
+
+object Macro:
+  inline def myMacro[T](): Unit =
+    ${ myMacroImpl[T]() }
+
+  def myMacroImpl[T: Type]()(using Quotes): Expr[Unit] =
+    import quotes.reflect.*
+    val myTypeRepr = MyTypeRepr(TypeRepr.of[T])
+
+    println(myTypeRepr.optionalAnnotationValue[caseName])
+    println(myTypeRepr.requiredAnnotationValue[caseName])
+
+    '{()}

tests/pos-macros/i22616c/MyTypeRepr_3.scala

@@ -0,0 +1,33 @@
+import scala.quoted.*
+
+final class MyTypeRepr(using val quotes: Quotes)(val unwrap: quotes.reflect.TypeRepr) {
+  import quotes.reflect.*
+
+  def getAnnotation(annotTpe: quotes.reflect.Symbol): Option[quotes.reflect.Term] =
+    unwrap.typeSymbol.getAnnotation(annotTpe)
+
+  def optionalAnnotation[Annot: Type]: Option[Expr[Annot]] = {
+    val annotTpe = TypeRepr.of[Annot]
+    val annotFlags = annotTpe.typeSymbol.flags
+
+    if (annotFlags.is(Flags.Abstract) || annotFlags.is(Flags.Trait))
+      report.errorAndAbort(s"Bad annotation type ${annotTpe.show} is abstract")
+
+    this.getAnnotation(annotTpe.typeSymbol) match
+      case Some(tree) if tree.tpe <:< annotTpe => Some(tree.asExprOf[Annot])
+      case _                                   => None
+  }
+
+  def requiredAnnotation[Annot: Type]: Expr[Annot] =
+    optionalAnnotation[Annot].getOrElse(report.errorAndAbort(s"Missing required annotation `${TypeRepr.of[Annot].show}` for `$this`"))
+
+  def optionalAnnotationValue[Annot: {Type, FromExpr}]: Option[Annot] =
+    optionalAnnotation[Annot].map { expr =>
+      expr.value.getOrElse(report.errorAndAbort(s"Found annotation `${TypeRepr.of[Annot].show}` for `$this`, but are unable to extract Expr.value\n${expr.show}"))
+    }
+
+  def requiredAnnotationValue[Annot: {Type, FromExpr}]: Annot = {
+    val expr = requiredAnnotation[Annot]
+    expr.value.getOrElse(report.errorAndAbort(s"Found annotation `${TypeRepr.of[Annot].show}` for `$this`, but are unable to extract Expr.value\n${expr.show}"))
+  }
+}

tests/pos-macros/i22616c/SealedTrait3_2.scala

@@ -0,0 +1,8 @@
+sealed trait SealedTrait3[+A, +B]
+object SealedTrait3 {
+  final case class AB1[+B, +A](a: B, b: A) extends SealedTrait3[B, A]
+  final case class AB2[+C, +D](a: C, b: D) extends SealedTrait3[D, C]
+  final case class A[+T](a: T) extends SealedTrait3[T, Nothing]
+  @caseName("_B_") final case class B[+T](b: T) extends SealedTrait3[Nothing, T]
+  case object Neither extends SealedTrait3[Nothing, Nothing]
+}

tests/pos-macros/i22616c/Test_5.scala

@@ -0,0 +1,2 @@
+@main def Test =
+  Macro.myMacro[SealedTrait3.B[Any]]()

tests/pos-macros/i22616c/caseName_1.scala

@@ -0,0 +1,18 @@
+import scala.quoted.*
+
+final case class caseName(name: String) extends scala.annotation.Annotation
+object caseName {
+  // This demonstrates a workaround for issue #22616.
+  given FromExpr[caseName] =
+    new FromExpr[caseName] {
+      override def unapply(x: Expr[caseName])(using Quotes): Option[caseName] =
+        import quotes.reflect.*
+        val typeSymbol = TypeRepr.of[caseName].typeSymbol
+        x.asTerm match {
+          case Apply(Select(New(clazz), _), List(nameArg)) if clazz.symbol == typeSymbol =>
+            Some(caseName(nameArg.asExprOf[String].valueOrAbort))
+          case _ =>
+            None
+        }
+    }
+}