Add workaround for #22616

Author: mbovel

tests/run-macros/i22616c.check

@@ -0,0 +1 @@
+_B_

tests/run-macros/i22616c/Macro_4.scala

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

tests/run-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/run-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/run-macros/i22616c/Test_5.scala

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

tests/run-macros/i22616c/caseName_1.scala

@@ -0,0 +1,14 @@
+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] =
+        x match {
+          case '{ new `caseName`(${ Expr(name) }) } => Some(caseName(name))
+          case _                                    => println(x.show); None
+        }
+    }
+}