Make tagName configurable on the upickle pickler basis (#603)

This functionaly was removed in
#579 when we made it
configurable via `@key`, but it's easy enough to support both config
mechanisms with `@key` taking precedence but `def tagName` being used as
a fallback

Author: lihaoyi

upickle/core/src/upickle/core/Config.scala

@@ -2,7 +2,13 @@ package upickle.core
 
 // Common things for derivation
 trait Config {
+  /**
+   * Specifies the name of the field used to distinguish different `case class`es under
+   * a `sealed trait`. Defaults to `$type`, but can be configured globally by overriding
+   * [[tagName]], or on a per-`sealed trait` basis via the `@key` annotation
+   */
   def tagName = Annotator.defaultTagKey
+
   /**
    * Whether to use the fully-qualified name of `case class`es and `case object`s which
    * are part of `sealed trait` hierarchies when serializing them and writing their `$type`

upickle/implicits/src-2/upickle/implicits/internal/Macros.scala

@@ -104,7 +104,7 @@ object Macros {
 
     }
 
-    def mergeTrait(tagKey: String, subtrees: Seq[Tree], subtypes: Seq[Type], targetType: c.Type): Tree
+    def mergeTrait(tagKey: Option[String], subtrees: Seq[Tree], subtypes: Seq[Type], targetType: c.Type): Tree
 
     def derive(tpe: c.Type) = {
       if (tpe.typeSymbol.asClass.isTrait || (tpe.typeSymbol.asClass.isAbstractClass && !tpe.typeSymbol.isJava)) {
@@ -127,7 +127,7 @@ object Macros {
             "https://com-lihaoyi.github.io/upickle/#ManualSealedTraitPicklers"
         fail(tpe, msg)
       }else{
-        val tagKey = customKey(clsSymbol).getOrElse(Annotator.defaultTagKey)
+        val tagKey = customKey(clsSymbol)
         val subTypes = fleshedOutSubtypes(tpe).toSeq.sortBy(_.typeSymbol.fullName)
         //    println("deriveTrait")
         val subDerives = subTypes.map(subCls => q"implicitly[${typeclassFor(subCls)}]")
@@ -241,7 +241,11 @@ object Macros {
             ).decodedName.toString
           )
 
-        q"${c.prefix}.annotate($derived, $tagKey, $tagValue, $shortTagValue)"
+        val tagKeyExpr = tagKey match {
+          case Some(v) => q"$v"
+          case None => q"${c.prefix}.tagName"
+        }
+        q"${c.prefix}.annotate($derived, $tagKeyExpr, $tagValue, $shortTagValue)"
       }
     }
 
@@ -363,8 +367,12 @@ object Macros {
       """
     }
 
-    override def mergeTrait(tagKey: String, subtrees: Seq[Tree], subtypes: Seq[Type], targetType: c.Type): Tree = {
-      q"${c.prefix}.Reader.merge[$targetType]($tagKey, ..$subtrees)"
+    override def mergeTrait(tagKey: Option[String], subtrees: Seq[Tree], subtypes: Seq[Type], targetType: c.Type): Tree = {
+      val tagKeyExpr = tagKey match {
+        case Some(v) => q"$v"
+        case None => q"${c.prefix}.tagName"
+      }
+      q"${c.prefix}.Reader.merge[$targetType]($tagKeyExpr, ..$subtrees)"
     }
   }
 
@@ -436,7 +444,7 @@ object Macros {
        """
     }
 
-    override def mergeTrait(tagKey: String, subtree: Seq[Tree], subtypes: Seq[Type], targetType: c.Type): Tree = {
+    override def mergeTrait(tagKey: Option[String], subtree: Seq[Tree], subtypes: Seq[Type], targetType: c.Type): Tree = {
       q"${c.prefix}.Writer.merge[$targetType](..$subtree)"
     }
   }

upickle/implicits/src-3/upickle/implicits/Readers.scala

@@ -78,14 +78,14 @@ trait ReadersVersionSpecific
       inline if macros.isSingleton[T] then
         annotate[T](
           SingletonReader[T](macros.getSingleton[T]),
-          macros.tagKey[T],
+          macros.tagKey[T](outerThis),
           macros.tagName[T],
           macros.shortTagName[T]
         )
       else if macros.isMemberOfSealedHierarchy[T] then
         annotate[T](
           reader,
-          macros.tagKey[T],
+          macros.tagKey[T](outerThis),
           macros.tagName[T],
           macros.shortTagName[T],
         )
@@ -97,7 +97,7 @@ trait ReadersVersionSpecific
         .toList
         .asInstanceOf[List[Reader[_ <: T]]]
 
-      Reader.merge[T](macros.tagKey[T], readers: _*)
+      Reader.merge[T](macros.tagKey[T](outerThis), readers: _*)
   }
 
   inline def macroRAll[T](using m: Mirror.Of[T]): Reader[T] = inline m match {
@@ -109,7 +109,7 @@ trait ReadersVersionSpecific
   inline given superTypeReader[T: Mirror.ProductOf, V >: T : Reader : Mirror.SumOf]
                               (using NotGiven[CurrentlyDeriving[V]]): Reader[T] = {
     val actual = implicitly[Reader[V]].asInstanceOf[TaggedReader[T]]
-    val tagKey = macros.tagKey[T]
+    val tagKey = macros.tagKey[T](outerThis)
     val tagName = macros.tagName[T]
     val shortTagName = macros.shortTagName[T]
     new TaggedReader.Leaf(tagKey, tagName, shortTagName, actual.findReader(tagName))

upickle/implicits/src-3/upickle/implicits/Writers.scala

@@ -13,7 +13,6 @@ trait WritersVersionSpecific
     with Annotator
     with CaseClassReadWriters:
 
-  val outerThis = this
   inline def macroW[T: ClassTag](using m: Mirror.Of[T]): Writer[T] = inline m match {
     case m: Mirror.ProductOf[T] =>
 
@@ -46,15 +45,15 @@ trait WritersVersionSpecific
       inline if macros.isSingleton[T] then
         annotate[T](
           SingletonWriter[T](null.asInstanceOf[T]),
-          macros.tagKey[T],
+          macros.tagKey[T](outerThis),
           macros.tagName[T],
           macros.shortTagName[T],
           Annotator.Checker.Val(macros.getSingleton[T]),
         )
       else if macros.isMemberOfSealedHierarchy[T] then
         annotate[T](
           writer,
-          macros.tagKey[T],
+          macros.tagKey[T](outerThis),
           macros.tagName[T],
           macros.shortTagName[T],
           Annotator.Checker.Cls(implicitly[ClassTag[T]].runtimeClass),

upickle/implicits/src-3/upickle/implicits/macros.scala

@@ -181,21 +181,23 @@ inline def isMemberOfSealedHierarchy[T]: Boolean = ${ isMemberOfSealedHierarchyI
 def isMemberOfSealedHierarchyImpl[T](using Quotes, Type[T]): Expr[Boolean] =
   Expr(sealedHierarchyParents[T].nonEmpty)
 
-inline def tagKey[T]: String = ${ tagKeyImpl[T] }
-def tagKeyImpl[T](using Quotes, Type[T]): Expr[String] =
+inline def tagKey[T](inline thisOuter: upickle.core.Types with upickle.implicits.MacrosCommon): String = ${ tagKeyImpl[T]('thisOuter) }
+def tagKeyImpl[T](using Quotes, Type[T])(thisOuter: Expr[upickle.core.Types with upickle.implicits.MacrosCommon]): Expr[String] =
   import quotes.reflect._
 
   // `case object`s extend from `Mirror`, which is `sealed` and will never have a `@key` annotation
   // so we need to filter it out to ensure it doesn't trigger an error in `tagKeyFromParents`
   val mirrorType = Symbol.requiredClass("scala.deriving.Mirror")
-
-  Expr(MacrosCommon.tagKeyFromParents(
+  MacrosCommon.tagKeyFromParents(
     Type.show[T],
     sealedHierarchyParents[T].filterNot(_ == mirrorType),
     extractKey,
     (_: Symbol).name,
     report.errorAndAbort,
-  ))
+  ) match{
+    case Some(v) => Expr(v)
+    case None => '{${thisOuter}.tagName}
+  }
 
 inline def tagName[T]: String = ${ tagNameImpl[T] }
 def tagNameImpl[T](using Quotes, Type[T]): Expr[String] =

upickle/implicits/src/upickle/implicits/MacrosCommon.scala

@@ -1,6 +1,8 @@
 package upickle.implicits
 
-trait MacrosCommon extends upickle.core.Config
+trait MacrosCommon extends upickle.core.Config with upickle.core.Types{
+  val outerThis = this
+}
 
 object MacrosCommon {
   def tagKeyFromParents[P](
@@ -9,16 +11,16 @@ object MacrosCommon {
     getKey: P => Option[String],
     getName: P => String,
     fail: String => Nothing,
-  ): String =
+  ): Option[String] =
     /**
       * Valid cases are:
       *
       * 1. None of the parents have a `@key` annotation
       * 2. All of the parents have the same `@key` annotation
       */
     sealedParents.flatMap(getKey(_)) match {
-      case Nil => upickle.core.Annotator.defaultTagKey
-      case keys @ (key :: _) if keys.length == sealedParents.length && keys.distinct.length == 1 => key
+      case Nil => None
+      case keys @ (key :: _) if keys.length == sealedParents.length && keys.distinct.length == 1 => Some(key)
       case keys =>
         fail(
           s"Type $typeName inherits from multiple parent types with different discriminator keys:\n\n" +

upickle/test/src/upickle/MacroTests.scala

@@ -125,6 +125,20 @@ object UnknownKeys{
     override def allowUnknownKeys = false
   }
 }
+
+object TagName{
+  object TagNamePickler extends upickle.AttributeTagged {
+    override def tagName = "_tag"
+  }
+
+  sealed trait Foo
+  case class Bar(x: Int) extends Foo
+  case class Qux(s: String) extends Foo
+
+  implicit val barRw: TagNamePickler.ReadWriter[Bar] = TagNamePickler.macroRW
+  implicit val quxRw: TagNamePickler.ReadWriter[Qux] = TagNamePickler.macroRW
+  implicit val fooRw: TagNamePickler.ReadWriter[Foo] = TagNamePickler.macroRW
+}
 object MacroTests extends TestSuite {
 
   // Doesn't work :(
@@ -849,5 +863,14 @@ object MacroTests extends TestSuite {
       )
 
     }
+
+    test("tagName"){
+      val customPicklerTest = new TestUtil(TagName.TagNamePickler)
+      customPicklerTest.rw(
+        TagName.Bar(123),
+        """{"_tag": "Bar", "x": 123}"""
+      )
+
+    }
   }
 }