wip upgrading to the new version of upickle

4 files changed, 41 insertions, 44 deletions

diff --git a/core/src/mill/define/Task.scala b/core/src/mill/define/Task.scala
index 17be54fe..63de11f6 100644
--- a/core/src/mill/define/Task.scala
+++ b/core/src/mill/define/Task.scala
@@ -57,34 +57,30 @@ trait Target[+T] extends NamedTask[T]{
 object Target extends TargetGenerated with Applicative.Applyer[Task, Task, Result, mill.util.Ctx] {
 
   implicit def apply[T](t: T)
-                       (implicit r: R[T],
-                        w: W[T],
+                       (implicit rw: RW[T],
                         ctx: mill.define.Ctx): Target[T] = macro targetImpl[T]
 
   def targetImpl[T: c.WeakTypeTag](c: Context)
                                   (t: c.Expr[T])
-                                  (r: c.Expr[R[T]],
-                                   w: c.Expr[W[T]],
+                                  (rw: c.Expr[RW[T]],
                                    ctx: c.Expr[mill.define.Ctx]): c.Expr[Target[T]] = {
     import c.universe._
     val lhs = Applicative.impl0[Task, T, mill.util.Ctx](c)(reify(Result.Success(t.splice)).tree)
 
     mill.moduledefs.Cacher.impl0[TargetImpl[T]](c)(
       reify(
-        new TargetImpl[T](lhs.splice, ctx.splice, RW(w.splice.write, r.splice.read))
+        new TargetImpl[T](lhs.splice, ctx.splice, rw.splice)
       )
     )
   }
 
   implicit def apply[T](t: Result[T])
-                       (implicit r: R[T],
-                        w: W[T],
+                       (implicit rw: RW[T],
                         ctx: mill.define.Ctx): Target[T] = macro targetResultImpl[T]
 
   def targetResultImpl[T: c.WeakTypeTag](c: Context)
                                         (t: c.Expr[Result[T]])
-                                        (r: c.Expr[R[T]],
-                                         w: c.Expr[W[T]],
+                                        (rw: c.Expr[RW[T]],
                                          ctx: c.Expr[mill.define.Ctx]): c.Expr[Target[T]] = {
     import c.universe._
     mill.moduledefs.Cacher.impl0[Target[T]](c)(
@@ -92,26 +88,24 @@ object Target extends TargetGenerated with Applicative.Applyer[Task, Task, Resul
         new TargetImpl[T](
           Applicative.impl0[Task, T, mill.util.Ctx](c)(t.tree).splice,
           ctx.splice,
-          RW(w.splice.write, r.splice.read)
+          rw.splice
         )
       )
     )
   }
 
   def apply[T](t: Task[T])
-              (implicit r: R[T],
-               w: W[T],
+              (implicit rw: RW[T],
                ctx: mill.define.Ctx): Target[T] = macro targetTaskImpl[T]
 
   def targetTaskImpl[T: c.WeakTypeTag](c: Context)
                                       (t: c.Expr[Task[T]])
-                                      (r: c.Expr[R[T]],
-                                       w: c.Expr[W[T]],
+                                      (rw: c.Expr[RW[T]],
                                        ctx: c.Expr[mill.define.Ctx]): c.Expr[Target[T]] = {
     import c.universe._
     mill.moduledefs.Cacher.impl0[Target[T]](c)(
       reify(
-        new TargetImpl[T](t.splice, ctx.splice, RW(w.splice.write, r.splice.read))
+        new TargetImpl[T](t.splice, ctx.splice, rw.splice)
       )
     )
   }
@@ -158,14 +152,12 @@ object Target extends TargetGenerated with Applicative.Applyer[Task, Task, Resul
     )
   }
   def input[T](value: Result[T])
-              (implicit r: R[T],
-                w: W[T],
+              (implicit rw: RW[T],
                 ctx: mill.define.Ctx): Input[T] = macro inputImpl[T]
 
   def inputImpl[T: c.WeakTypeTag](c: Context)
                                   (value: c.Expr[T])
-                                  (r: c.Expr[R[T]],
-                                   w: c.Expr[W[T]],
+                                  (rw: c.Expr[RW[T]],
                                    ctx: c.Expr[mill.define.Ctx]): c.Expr[Input[T]] = {
     import c.universe._
 
@@ -174,7 +166,7 @@ object Target extends TargetGenerated with Applicative.Applyer[Task, Task, Resul
         new Input[T](
           Applicative.impl[Task, T, mill.util.Ctx](c)(value).splice,
           ctx.splice,
-          RW(w.splice.write, r.splice.read)
+          rw.splice
         )
       )
     )
@@ -229,14 +221,12 @@ object Target extends TargetGenerated with Applicative.Applyer[Task, Task, Resul
 
   def task[T](t: Result[T]): Task[T] = macro Applicative.impl[Task, T, mill.util.Ctx]
 
-  def persistent[T](t: Result[T])(implicit r: R[T],
-                                  w: W[T],
+  def persistent[T](t: Result[T])(implicit rw: RW[T],
                                   ctx: mill.define.Ctx): Persistent[T] = macro persistentImpl[T]
 
   def persistentImpl[T: c.WeakTypeTag](c: Context)
                                       (t: c.Expr[T])
-                                      (r: c.Expr[R[T]],
-                                       w: c.Expr[W[T]],
+                                      (rw: c.Expr[RW[T]],
                                        ctx: c.Expr[mill.define.Ctx]): c.Expr[Persistent[T]] = {
     import c.universe._
 
@@ -246,7 +236,7 @@ object Target extends TargetGenerated with Applicative.Applyer[Task, Task, Resul
         new Persistent[T](
           Applicative.impl[Task, T, mill.util.Ctx](c)(t).splice,
           ctx.splice,
-          RW(w.splice.write, r.splice.read)
+          rw.splice
         )
       )
     )
@@ -314,9 +304,9 @@ class Sources(t: Task[Seq[PathRef]],
               ctx0: mill.define.Ctx) extends Input[Seq[PathRef]](
   t,
   ctx0,
-  RW(
-    upickle.default.SeqishW[PathRef, Seq].write,
-    upickle.default.SeqishR[Seq, PathRef].read
+  RW.join(
+    upickle.default.SeqLikeReader[Seq, PathRef],
+    upickle.default.SeqLikeWriter[Seq, PathRef]
   )
 )
 object Task {
diff --git a/core/src/mill/eval/Evaluator.scala b/core/src/mill/eval/Evaluator.scala
index 1e1b8b35..f8fecf38 100644
--- a/core/src/mill/eval/Evaluator.scala
+++ b/core/src/mill/eval/Evaluator.scala
@@ -128,11 +128,15 @@ case class Evaluator[T](home: Path,
 
         if (!exists(paths.out)) mkdir(paths.out)
         val cached = for{
-          json <- scala.util.Try(upickle.json.read(paths.meta.toIO)).toOption
-          cached <- scala.util.Try(upickle.default.readJs[Evaluator.Cached](json)).toOption
+          cached <-
+            try Some(upickle.default.read[Evaluator.Cached](paths.meta.toIO))
+            catch {case e: Throwable => None}
+
           if cached.inputsHash == inputsHash
           reader <- labelledNamedTask.format
-          parsed <- reader.read.lift(cached.v)
+          parsed <-
+            try Some(upickle.default.read(cached.v)(reader))
+            catch {case e: Throwable => None}
         } yield (parsed, cached.valueHash)
 
         val workerCached = labelledNamedTask.task.asWorker
@@ -195,7 +199,7 @@ case class Evaluator[T](home: Path,
         val terminalResult = labelledNamedTask
           .writer
           .asInstanceOf[Option[upickle.default.Writer[Any]]]
-          .map(_.write(v) -> v)
+          .map(w => upickle.default.writeJs(v)(w) -> v)
 
         for((json, v) <- terminalResult){
           write.over(
diff --git a/core/src/mill/util/AggWrapper.scala b/core/src/mill/util/AggWrapper.scala
index eefe6224..6c107875 100644
--- a/core/src/mill/util/AggWrapper.scala
+++ b/core/src/mill/util/AggWrapper.scala
@@ -30,10 +30,11 @@ sealed class AggWrapper(strictUniqueness: Boolean){
   object Agg{
     def empty[V]: Agg[V] = new Agg.Mutable[V]
     implicit def jsonFormat[T: upickle.default.ReadWriter]: upickle.default.ReadWriter[Agg[T]] =
-      upickle.default.ReadWriter[Agg[T]] (
-        oset => upickle.default.writeJs(oset.toList),
-        {case json => Agg.from(upickle.default.readJs[Seq[T]](json))}
+      upickle.default.readwriter[Seq[T]].bimap[Agg[T]](
+        _.toList,
+        Agg.from(_)
       )
+
     def apply[V](items: V*) = from(items)
 
     implicit def from[V](items: TraversableOnce[V]): Agg[V] = {
diff --git a/core/src/mill/util/JsonFormatters.scala b/core/src/mill/util/JsonFormatters.scala
index 00a40e7d..f92941f7 100644
--- a/core/src/mill/util/JsonFormatters.scala
+++ b/core/src/mill/util/JsonFormatters.scala
@@ -5,15 +5,17 @@ import upickle.Js
 import upickle.default.{ReadWriter => RW}
 object JsonFormatters extends JsonFormatters
 trait JsonFormatters {
-  implicit val pathReadWrite: RW[ammonite.ops.Path] = RW[ammonite.ops.Path](
-    o => Js.Str(o.toString()),
-    {case Js.Str(json) => Path(json.toString)},
-  )
+  implicit val pathReadWrite: RW[ammonite.ops.Path] = upickle.default.readwriter[String]
+    .bimap[ammonite.ops.Path](
+      _.toString,
+      Path(_)
+    )
 
-  implicit val bytesReadWrite: RW[Bytes] = RW[Bytes](
-    o => Js.Str(javax.xml.bind.DatatypeConverter.printBase64Binary(o.array)),
-    {case Js.Str(json) => new Bytes(javax.xml.bind.DatatypeConverter.parseBase64Binary(json.toString))}
-  )
+  implicit val bytesReadWrite: RW[Bytes] = upickle.default.readwriter[String]
+    .bimap(
+      o => javax.xml.bind.DatatypeConverter.printBase64Binary(o.array),
+      str => new Bytes(javax.xml.bind.DatatypeConverter.parseBase64Binary(str))
+    )
 
 
   implicit lazy val crFormat: RW[ammonite.ops.CommandResult] = upickle.default.macroRW
@@ -21,7 +23,7 @@ trait JsonFormatters {
   implicit lazy val modFormat: RW[coursier.Module] = upickle.default.macroRW
   implicit lazy val depFormat: RW[coursier.Dependency]= upickle.default.macroRW
   implicit lazy val attrFormat: RW[coursier.Attributes] = upickle.default.macroRW
-  implicit val stackTraceRW = upickle.default.ReadWriter[StackTraceElement](
+  implicit val stackTraceRW = upickle.default.readwriter[Js.Obj].bimap[StackTraceElement](
     ste => Js.Obj(
       "declaringClass" -> Js.Str(ste.getClassName),
       "methodName" -> Js.Str(ste.getMethodName),