Consolidate tests and remove redundant package object rewriting

The PR #1 fix (.withMods preserving Package flag on ModuleDef) is the
proper solution for package object support — remove our PackageDef
rewriting workaround which broke nested package object type visibility.

Merge NewTypeApiTest into NewTypeMacrosTest (Coercible wrapM/unwrapM,
unsafeWrapMM, parameterized accessor, instance method chaining) and
NewTypeCatsTest (Order.by/Show.show/Eq.by companion patterns). Remove
the now-empty duplicate file.

Author: MateuszKubuszok

plugin/src/main/scala/io/estatico/newtype/compat/NewTypeTreeTransformer.scala

@@ -298,16 +298,7 @@ class NewTypeTreeTransformer extends UntypedTreeMap:
 
   override def transform(tree: Tree)(using Context): Tree = tree match
     case PackageDef(pid, stats) =>
-      val transformedPid = transform(pid).asInstanceOf[RefTree]
-      stats.partition { case md: ModuleDef => md.mods.is(Package); case _ => false } match
-        case (pkgObj :: Nil, otherStats) =>
-          val md = pkgObj.asInstanceOf[ModuleDef]
-          val innerBody = transformStats(md.impl.body)
-          val allInnerStats = otherStats.map(transform) ++ innerBody
-          val newPid = Select(transformedPid, md.name)
-          untpd.PackageDef(newPid, allInnerStats)
-        case _ =>
-          cpy.PackageDef(tree)(transformedPid, transformStats(stats))
+      cpy.PackageDef(tree)(transform(pid).asInstanceOf[RefTree], transformStats(stats))
     case Block(stats, expr) =>
       cpy.Block(tree)(transformStats(stats), transform(expr))
     case td @ TypeDef(name, rhs: Template) if !findNewTypeAnnotation(td).isDefined =>

tests/src/test/scala/io/estatico/newtype/NewTypeApiTest.scala

@@ -2,10 +2,9 @@ package io.estatico.newtype
 
 import io.estatico.newtype.macros._
 import io.estatico.newtype.ops._
+import cats.{Eq, Order, Show}
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
-import cats._
-import cats.syntax.all._
 
 class NewTypeCatsTest extends AnyFlatSpec with Matchers {
 
@@ -14,7 +13,6 @@ class NewTypeCatsTest extends AnyFlatSpec with Matchers {
   behavior of "@newtype with cats"
 
   it should "derive Eq instance" in {
-    implicit val eqInt: Eq[Int] = Eq.fromUniversalEquals
     val eqFoo: Eq[Foo] = Foo.deriving[Eq]
     eqFoo.eqv(Foo(1), Foo(1)) shouldBe true
     eqFoo.eqv(Foo(1), Foo(2)) shouldBe false
@@ -31,8 +29,37 @@ class NewTypeCatsTest extends AnyFlatSpec with Matchers {
     val i: Int = foo.coerce[Int]
     i shouldBe 42
   }
+
+  it should "resolve Order.by(_.value) in companion" in {
+    val ord = implicitly[Order[Name]]
+    ord.compare(Name("Alice"), Name("Bob")) should be < 0
+    ord.compare(Name("Bob"), Name("Alice")) should be > 0
+    ord.compare(Name("Alice"), Name("Alice")) shouldBe 0
+  }
+
+  it should "resolve Show.show(_.value) in companion" in {
+    val show = implicitly[Show[Name]]
+    show.show(Name("Alice")) shouldBe "Alice"
+  }
+
+  it should "resolve Eq.by(_.value) in companion" in {
+    val eq = implicitly[Eq[Score]]
+    eq.eqv(Score(10), Score(10)) shouldBe true
+    eq.eqv(Score(10), Score(20)) shouldBe false
+  }
 }
 
 object NewTypeCatsTest {
   @newtype case class Foo(x: Int)
+
+  @newtype case class Name(value: String)
+  object Name {
+    implicit val orderForName: Order[Name] = Order.by(_.value)
+    implicit val showForName: Show[Name] = Show.show(_.value)
+  }
+
+  @newtype case class Score(value: Int)
+  object Score {
+    implicit val eqForScore: Eq[Score] = Eq.by(_.value)
+  }
 }

tests/src/test/scala/io/estatico/newtype/NewTypeCatsTest.scala

@@ -28,6 +28,11 @@ class NewTypeMacrosTest extends AnyFlatSpec with Matchers {
     x.coerce[List[Int]] shouldBe List(1, 2, 3)
   }
 
+  it should "provide field accessor for parameterized newtype" in {
+    val x = Baz(List("a", "b"))
+    x.xs shouldBe List("a", "b")
+  }
+
   it should "support deriving" in {
     implicit val showInt: Show[Int] = (a: Int) => a.toString
     val showFoo: Show[Foo] = Foo.deriving[Show]
@@ -39,6 +44,12 @@ class NewTypeMacrosTest extends AnyFlatSpec with Matchers {
     x.plus(5) shouldBe HasMethods(15)
   }
 
+  it should "support instance methods with chaining" in {
+    val c = HasMethods(0)
+    c.increment shouldBe HasMethods(1)
+    c.increment.increment shouldBe HasMethods(2)
+  }
+
   it should "support unapply when enabled" in {
     val x = WithUnapply(99)
     val result = x match {
@@ -65,6 +76,8 @@ class NewTypeMacrosTest extends AnyFlatSpec with Matchers {
     x.coerce[Int] shouldBe 7
   }
 
+  behavior of "Coercible"
+
   it should "support Coercible wrapping/unwrapping" in {
     val w = implicitly[Coercible[Int, Foo]]
     val u = implicitly[Coercible[Foo, Int]]
@@ -78,6 +91,19 @@ class NewTypeMacrosTest extends AnyFlatSpec with Matchers {
     val int = foo.coerce[Int]
     int shouldBe 42
   }
+
+  it should "provide implicit wrapM and unwrapM" in {
+    val wm = implicitly[Coercible[List[Int], List[Foo]]]
+    val um = implicitly[Coercible[List[Foo], List[Int]]]
+    val foos = wm(List(1, 2))
+    um(foos) shouldBe List(1, 2)
+  }
+
+  it should "coerce nested type constructors via Coercible.unsafeWrapMM" in {
+    val nested: Option[List[Int]] = Some(List(1, 2, 3))
+    val coerced = implicitly[Coercible[Option[List[Int]], Option[List[Foo]]]].apply(nested)
+    coerced shouldBe Some(List(1, 2, 3))
+  }
 }
 
 object NewTypeMacrosTest {
@@ -93,6 +119,7 @@ object NewTypeMacrosTest {
 
   @newtype case class HasMethods(value: Int) {
     def plus(other: Int): HasMethods = HasMethods(value + other)
+    def increment: HasMethods = HasMethods(value + 1)
   }
 
   @newtype(unapply = true) case class WithUnapply(x: Int)