Merge pull request #100 from scala/issue/75

Fix #75 - Runtime exception when unpickling Array of Tuple

Author: heathermiller

core/src/main/scala/pickling/internal/AppliedType.scala

@@ -0,0 +1,41 @@
+package scala.pickling.internal
+
+object AppliedType {
+  // the delimiters in an applied type
+  private val delims = List(',', '[', ']')
+
+  /* Parse an applied type.
+   *
+   * @param  s the string that is parsed
+   * @return   a pair with the parsed applied type and the remaining string.
+   */
+  def parse(s: String): (AppliedType, String) = {
+    // shape of `s`: fqn[at_1, ..., at_n]
+    val (typename, rem) = s.span(!delims.contains(_))
+
+    if (rem.isEmpty || rem.startsWith(",") || rem.startsWith("]")) {
+      (AppliedType(typename, List()), rem)
+    } else { // parse type arguments
+      var typeArgs  = List[AppliedType]()
+      var remaining = rem
+
+      while (remaining.startsWith("[") || remaining.startsWith(",")) {
+        remaining = remaining.substring(1)
+        val (nextAppliedType, rem) = parse(remaining)
+        typeArgs = typeArgs :+ nextAppliedType
+        remaining = rem
+      }
+
+      (AppliedType(typename, typeArgs), if (remaining.startsWith("]")) remaining.substring(1) else remaining)
+    }
+  }
+
+}
+
+/**
+ * Simple representation of an applied type. Used for reading pickled types.
+ */
+case class AppliedType(typename: String, typeargs: List[AppliedType]) {
+  override def toString =
+    typename + (if (typeargs.isEmpty) "" else typeargs.mkString("[", ",", "]"))
+}

core/src/main/scala/pickling/internal/package.scala

@@ -46,22 +46,17 @@ package object internal {
     // TODO: find out why typeFromString is called repeatedly for scala.Predef.String (at least in the evactor1 bench)
     if (typeFromStringCache.contains(stpe)) typeFromStringCache(stpe)
     else {
-      val result = {
-        val (ssym, stargs) = {
-          val Pattern = """^(.*?)(\[(.*?)\])?$""".r
-          def fail() = throw new PicklingException(s"fatal: cannot unpickle $stpe")
-          stpe match {
-            case Pattern("", _, _) => fail()
-            case Pattern(sym, _, null) => (sym, Nil)
-            case Pattern(sym, _, stargs) => (sym, stargs.split(",").map(_.trim).toList)
-            case _ => fail()
-          }
+      val result =
+        AppliedType.parse(stpe) match {
+          case (AppliedType(typename, appliedTypeArgs), _) =>
+            val sym =
+              if (typename.endsWith(".type")) mirror.staticModule(typename.stripSuffix(".type")).moduleClass
+              else mirror.staticClass(typename)
+            val tycon = sym.asType.toTypeConstructor
+            appliedType(tycon, appliedTypeArgs.map(starg => typeFromString(mirror, starg.toString)))
+          case _ =>
+            sys.error(s"fatal: cannot unpickle $stpe")
         }
-
-        val sym = if (ssym.endsWith(".type")) mirror.staticModule(ssym.stripSuffix(".type")).moduleClass else mirror.staticClass(ssym)
-        val tycon = sym.asType.toTypeConstructor
-        appliedType(tycon, stargs.map(starg => typeFromString(mirror, starg)))
-      }
       typeFromStringCache(stpe) = result
       result
     }

core/src/test/scala/pickling/pickling-spec.scala

@@ -253,6 +253,18 @@ object PicklingJsonSpec extends Properties("pickling-json") {
     readArr.sameElements(ia)
   })
 
+  property("Array[(Int, Double)]") = forAll((ia: Array[(Int, Double)]) => {
+    val pickle: JSONPickle = ia.pickle
+    val readArr = pickle.unpickle[Array[(Int, Double)]]
+    readArr.sameElements(ia)
+  })
+
+  property("Array[(String, Int)]") = forAll((ia: Array[(String, Int)]) => {
+    val pickle: JSONPickle = ia.pickle
+    val readArr = pickle.unpickle[Array[(String, Int)]]
+    readArr.sameElements(ia)
+  })
+
   property("BigDecimal") = Prop forAll { (x: Double) =>
     val bd = new BigDecimal(x)
     val pickle: JSONPickle = bd.pickle
@@ -477,6 +489,18 @@ object PicklingBinarySpec extends Properties("pickling-binary") {
     readArr.sameElements(ia)
   })
 
+  property("Array[(Int, Double)]") = forAll((ia: Array[(Int, Double)]) => {
+    val pickle: BinaryPickle = ia.pickle
+    val readArr = pickle.unpickle[Array[(Int, Double)]]
+    readArr.sameElements(ia)
+  })
+
+  property("Array[(String, Int)]") = forAll((ia: Array[(String, Int)]) => {
+    val pickle: BinaryPickle = ia.pickle
+    val readArr = pickle.unpickle[Array[(String, Int)]]
+    readArr.sameElements(ia)
+  })
+
   property("BigDecimal") = Prop forAll { (x: Double) =>
     val bd = new BigDecimal(x)
     val pickle: BinaryPickle = bd.pickle