BinaryPickle - unpickling something that contains empty Maps fails

[ktoso]

package com.typesafe

import akka.util.ByteString
import akka.actor.Address
import akka.serialization.Serializer
import scala.pickling._
import scala.pickling.Defaults._
import scala.pickling.binary._

import scala.pickling.binary.BinaryPickle

class SanitySpec extends AkkaUnitTest {

  case class MyValue(protocol: String, servicePort: Int, serviceName: String)

  "Binary and Map[String, Map[String, MyValue]" should {

    // this is OK:
    "pickle" in {
      val bytes = Map("hello" -> Map("one" -> MyValue("pop", 23, "email"))).pickle.value
      val got = BinaryPickle(bytes).unpickle[Map[String, Map[String, MyValue]]]
    }

    // this is OK:
    "pickle empty inner - with types" in {
      val bytes = Map("hello" -> Map[String, MyValue]()).pickle.value
      val got = BinaryPickle(bytes).unpickle[Map[String, Map[String, MyValue]]]
    }


   // this FAILS:
    "pickle empty inner - no types" in {
      val bytes = Map("hello" -> Map()).pickle.value
      info("pickle = " + ByteString(bytes).utf8String)
      val got = BinaryPickle(bytes).unpickle[Map[String, Map[String, MyValue]]]
/*
[info] - should pickle empty inner - no types *** FAILED ***
[info]   java.lang.ArrayIndexOutOfBoundsException: 263
[info]   at scala.pickling.binary.ByteArrayInput.getInt(BinaryInput.scala:156)
[info]   at scala.pickling.binary.BinaryPickleReader.readLength(BinaryPickle.scala:255)
[info]   at scala.pickling.pickler.TravPickler$$anon$1.unpickle(Iterable.scala:59)
[info]   at com.typesafe.SanitySpec$$anonfun$2$$anonfun$apply$mcV$sp$4$ScalaTuple2$u005BjavaLangString$u002CscalaCollectionImmutableMap$u005BjavaLangString$u002CScalaPicklingSerializerSpecThisMyValue$u005D$u005DUnpickler$macro$619$2$.unpickle(ScalaPicklingSerializerSpec.scala:58)
[info]   at scala.pickling.Unpickler$class.unpickleEntry(Pickler.scala:81)
[info]   at com.typesafe.SanitySpec$$anonfun$2$$anonfun$apply$mcV$sp$4$ScalaTuple2$u005BjavaLangString$u002CscalaCollectionImmutableMap$u005BjavaLangString$u002CScalaPicklingSerializerSpecThisMyValue$u005D$u005DUnpickler$macro$619$2$.unpickleEntry(ScalaPicklingSerializerSpec.scala:58)
[info]   at scala.pickling.pickler.TravPickler$$anon$1.unpickle(Iterable.scala:64)
[info]   at scala.pickling.Unpickler$class.unpickleEntry(Pickler.scala:81)
[info]   at scala.pickling.pickler.TravPickler$$anon$1.unpickleEntry(Iterable.scala:18)
[info]   at scala.pickling.functions$.unpickle(functions.scala:11)
[info]   ...
*/
    }

  }
}

The pickled bytes look like this:

[info]   + pickle = lscala.collection.immutable.Map[java.lang.String,scala.collection.immutable.Map[scala.Nothing,scala.Nothing]]Zscala.Tuple2[java.lang.String,scala.collection.immutable.Map[scala.Nothing,scala.Nothing]]hello(scala.collection.immutable.Map$EmptyMap$

So yeah, Nothing is inferred and captures, but it still should be able to deserialize I think, using an empty Map literal is very useful at times - initialising empty data structures etc.

// this was on 0.10.0

[eed3si9n]

The original issue name "BinaryPickle - unpickling something that contains empty Maps fails" is stated as if this is a bug, but this is more of a feature request.

scala> import scala.pickling._, scala.pickling.Defaults._, scala.pickling.binary._
import scala.pickling._
import scala.pickling.Defaults._
import scala.pickling.binary._

scala> val x = Map("hello" -> Map())
x: scala.collection.immutable.Map[String,scala.collection.immutable.Map[Nothing,Nothing]] = Map(hello -> Map())

scala> val pkl = x.pickle.value
pkl: Array[Byte] = Array(0, 0, 0, 108, 115, 99, 97, 108, 97, 46, 99, 111, 108, 108, 101, 99, 116, 105, 111, 110, 46, 105, 109, 109, 117, 116, 97, 98, 108, 101, 46, 77, 97, 112, 91, 106, 97, 118, 97, 46, 108, 97, 110, 103, 46, 83, 116, 114, 105, 110, 103, 44, 115, 99, 97, 108, 97, 46, 99, 111, 108, 108, 101, 99, 116, 105, 111, 110, 46, 105, 109, 109, 117, 116, 97, 98, 108, 101, 46, 77, 97, 112, 91, 115, 99, 97, 108, 97, 46, 78, 111, 116, 104, 105, 110, 103, 44, 115, 99, 97, 108, 97, 46, 78, 111, 116, 104, 105, 110, 103, 93, 93, 0, 0, 0, 1, 0, 0, 0, 90, 115, 99, 97, 108, 97, 46, 84, 117, 112, 108, 101, 50, 91, 106, 97, 118, 97, 46, 108, 97, 110, 103, 46, 83, 116, 114, 105, 110, 103, 44, 115, 99, 97, 108, 97, 46, 99, 111, 108, 108, 101, 99, 116, 105, 111, 110, 46, 105, 109, 109, 117, 116, ...
scala> case class MyValue(protocol: String, servicePort: Int, serviceName: String)
defined class MyValue

scala> pkl.unpickle[Map[String, Map[String, MyValue]]]
java.lang.ArrayIndexOutOfBoundsException: 263
  at scala.pickling.binary.ByteArrayInput.getInt(BinaryInput.scala:152)
  at scala.pickling.binary.BinaryPickleReader.readLength(BinaryPickle.scala:251)
  at scala.pickling.pickler.TravPickler$$anon$1.unpickle(Iterable.scala:59)
  at ScalaTuple2$u005BjavaLangString$u002CscalaCollectionImmutableMap$u005BjavaLangString$u002C$line6$readiwiwiwiwMyValue$u005D$u005DUnpickler$macro$25$2$.unpickle(<console>:21)
  at scala.pickling.pickler.TravPickler$$anon$1.unpickle(Iterable.scala:65)
  at scala.pickling.Unpickler$class.unpickleEntry(Pickler.scala:79)
  at scala.pickling.pickler.TravPickler$$anon$1.unpickleEntry(Iterable.scala:18)
  at scala.pickling.functions$.unpickle(functions.scala:11)
  at scala.pickling.UnpickleOps.unpickle(Ops.scala:23)
  ... 43 elided

scala> pkl.unpickle[Map[String, Map[String, Nothing]]]
res1: Map[String,Map[String,Nothing]] = Map(hello -> Map())

In the above, x is type inferenced to be Map[String, Map[Nothing, Nothing]], and that's how it's pickled. What you're asking is a form of duck typing that not even Scala would do:

scala> val empty = Map()
empty: scala.collection.immutable.Map[Nothing,Nothing] = Map()

scala> val y: Map[String, MyValue] = empty
<console>:19: error: type mismatch;
 found   : scala.collection.immutable.Map[Nothing,Nothing]
 required: Map[String,MyValue]
Note: Nothing <: String, but trait Map is invariant in type A.
You may wish to investigate a wildcard type such as `_ <: String`. (SLS 3.2.10)
       val y: Map[String, MyValue] = empty
                                     ^

While I recognize the desire for duck typing (it's useful for growing API), the underlying issue here is that it's possible to pickle Map[Nothing, Nothing] in the first place.