Patch implementation of Const.unapply

* Make sure the extrators does not match classes. This should be done using reflection.
* Do not match `'{null}` to avoid accidental NPEs.
* Do not match `'{}` as there is no value to extract.

```diff
- case Const(null) =>
+ case '{null} =>

- case Const(()) =>
+ case '{} =>
```

We specialize use the old, faster, implemtation for `Unliftable` as there it it correct by construction of the available `Unliftable`s.

Author: nicolasstucki

library/src-bootstrapped/scala/quoted/Unliftable.scala

@@ -80,7 +80,16 @@ object Unliftable {
 
   /** Lift a quoted primitive value `'{ x }` into `x` */
   private class PrimitiveUnliftable[T <: Int | Boolean | Byte | Short | Int | Long | Float | Double | Char | String] extends Unliftable[T] {
-    def fromExpr(x: Expr[T]) = Const.unapply(x)
+    def fromExpr(expr: Expr[T]) =
+      import quotes.reflect._
+      def rec(tree: Term): Option[T] = tree match {
+        case Literal(c) => Some(c.value.asInstanceOf[T])
+        case Block(Nil, e) => rec(e)
+        case Typed(e, _) => rec(e)
+        case Inlined(_, Nil, e) => rec(e)
+        case _  => None
+      }
+      rec(Term.of(expr))
   }
 
   /** Default unliftable for Option

library/src/scala/quoted/Const.scala

@@ -21,7 +21,12 @@ object Const {
   def unapply[T](expr: Expr[T])(using Quotes): Option[T] = {
     import quotes.reflect._
     def rec(tree: Term): Option[T] = tree match {
-      case Literal(c) => Some(c.value.asInstanceOf[T])
+      case Literal(c) =>
+        c match
+          case Constant.Null() => None
+          case Constant.Unit() => None
+          case Constant.ClassOf(_) => None
+          case _ => Some(c.value.asInstanceOf[T])
       case Block(Nil, e) => rec(e)
       case Typed(e, _) => rec(e)
       case Inlined(_, Nil, e) => rec(e)

tests/run-macros/tasty-extractors-constants-1/quoted_1.scala

@@ -14,7 +14,7 @@ object Macros {
     Expr(3) match { case Const(n) => stagedPrintln(n) }
     '{4} match { case Const(n) => stagedPrintln(n) }
     '{"abc"} match { case Const(n) => stagedPrintln(n) }
-    '{null} match { case Const(n) => stagedPrintln(n) }
+    '{null} match { case '{null} => stagedPrintln(null) }
 
     '{new Object} match { case Const(n) => println(n); case _ => stagedPrintln("OK") }