Hardcode the lifters as definitions

Author: nicolasstucki

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

@@ -637,8 +637,16 @@ class Definitions {
   @tu lazy val QuoteContextModule: Symbol = QuoteContextClass.companionModule
     @tu lazy val QuoteContext_macroContext: Symbol = QuoteContextModule.requiredMethod("macroContext")
 
-  @tu lazy val LiftableClass: ClassSymbol = ctx.requiredClass("scala.quoted.Liftable")
   @tu lazy val LiftableModule: Symbol = ctx.requiredModule("scala.quoted.Liftable")
+    @tu lazy val LiftableModule_BooleanIsLiftable: Symbol = LiftableModule.requiredMethod("BooleanIsLiftable")
+    @tu lazy val LiftableModule_ByteIsLiftable: Symbol = LiftableModule.requiredMethod("ByteIsLiftable")
+    @tu lazy val LiftableModule_ShortIsLiftable: Symbol = LiftableModule.requiredMethod("ShortIsLiftable")
+    @tu lazy val LiftableModule_IntIsLiftable: Symbol = LiftableModule.requiredMethod("IntIsLiftable")
+    @tu lazy val LiftableModule_LongIsLiftable: Symbol = LiftableModule.requiredMethod("LongIsLiftable")
+    @tu lazy val LiftableModule_FloatIsLiftable: Symbol = LiftableModule.requiredMethod("FloatIsLiftable")
+    @tu lazy val LiftableModule_DoubleIsLiftable: Symbol = LiftableModule.requiredMethod("DoubleIsLiftable")
+    @tu lazy val LiftableModule_CharIsLiftable: Symbol = LiftableModule.requiredMethod("CharIsLiftable")
+    @tu lazy val LiftableModule_StringIsLiftable: Symbol = LiftableModule.requiredMethod("StringIsLiftable")
 
   @tu lazy val InternalQuotedModule: Symbol = ctx.requiredModule("scala.internal.Quoted")
     @tu lazy val InternalQuoted_exprQuote  : Symbol = InternalQuotedModule.requiredMethod("exprQuote")

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

@@ -206,17 +206,23 @@ class ReifyQuotes extends MacroTransform {
         qctx
       }
 
-      def pickleAsLiteral(lit: Literal) =
+      def pickleAsLiteral(lit: Literal) = {
+        def liftedValue(lifter: Symbol) =
+          ref(lifter).appliedToType(originalTp).select(nme.toExpr).appliedTo(lit)
         lit.const.tag match {
           case Constants.NullTag => ref(defn.QuotedExprModule_nullExpr)
           case Constants.UnitTag => ref(defn.QuotedExprModule_unitExpr)
-          case _ => // Lifted literal
-            val ltp = defn.LiftableClass.typeRef.appliedTo(ConstantType(lit.const))
-            val liftable = ctx.typer.inferImplicitArg(ltp, body.span)
-            if (liftable.tpe.isInstanceOf[SearchFailureType])
-              ctx.error(ctx.typer.missingArgMsg(liftable, ltp, "Could no optimize constant in quote"), ctx.source.atSpan(body.span))
-            liftable.select(nme.toExpr).appliedTo(lit)
+          case Constants.BooleanTag => liftedValue(defn.LiftableModule_BooleanIsLiftable)
+          case Constants.ByteTag => liftedValue(defn.LiftableModule_ByteIsLiftable)
+          case Constants.ShortTag => liftedValue(defn.LiftableModule_ShortIsLiftable)
+          case Constants.IntTag => liftedValue(defn.LiftableModule_IntIsLiftable)
+          case Constants.LongTag => liftedValue(defn.LiftableModule_LongIsLiftable)
+          case Constants.FloatTag => liftedValue(defn.LiftableModule_FloatIsLiftable)
+          case Constants.DoubleTag => liftedValue(defn.LiftableModule_DoubleIsLiftable)
+          case Constants.CharTag => liftedValue(defn.LiftableModule_CharIsLiftable)
+          case Constants.StringTag => liftedValue(defn.LiftableModule_StringIsLiftable)
         }
+      }
 
       def pickleAsTasty() = {
         val meth =