From 411b317d097e3af1f5d1e3bce28bb910a944a8c3 Mon Sep 17 00:00:00 2001 From: Jacob Wang Date: Wed, 3 Jun 2026 23:04:21 +0100 Subject: [PATCH] Use ProductDiffer for case class and tuples --- .../main/scala/difflicious/DiffBench.scala | 31 ++++- .../difflicious/DifferDerivationMacros.scala | 34 +++--- .../src/main/scala/difflicious/PairType.scala | 6 +- .../difflicious/differ/ProductDiffer.scala | 112 ++++++++++++++++++ .../derived-recursive-tree.scala | 2 +- .../derivedDeep-recursive-tree.scala | 2 +- .../derivedDeep-tree.scala | 10 +- .../derived-recursive-tree.scala | 2 +- .../derivedDeep-recursive-tree.scala | 2 +- .../derivedDeep-tree.scala | 10 +- .../test/scala/difflicious/DifferSpec.scala | 18 +-- project/TupleDifferInstancesGen.scala | 9 +- 12 files changed, 185 insertions(+), 53 deletions(-) create mode 100644 modules/core/src/main/scala/difflicious/differ/ProductDiffer.scala diff --git a/modules/benchmarks/src/main/scala/difflicious/DiffBench.scala b/modules/benchmarks/src/main/scala/difflicious/DiffBench.scala index e8bedad..d1509bd 100644 --- a/modules/benchmarks/src/main/scala/difflicious/DiffBench.scala +++ b/modules/benchmarks/src/main/scala/difflicious/DiffBench.scala @@ -2,6 +2,7 @@ package difflicious import java.util.concurrent.TimeUnit +import difflicious.differ.ValueDiffer import org.openjdk.jmh.annotations.* import org.openjdk.jmh.infra.Blackhole @@ -13,11 +14,17 @@ class DiffBench { val big = Big( 12, "asdfa", + Map(Key("a", 1) -> Dog("fido", 3.5)), + Vector(Dog("spot", 7.0)), + Set(Dog("rex", 2.0)), ) val bigClone = Big( 12, "asdfa", + Map(Key("a", 1) -> Dog("fido", 3.5)), + Vector(Dog("spot", 7.0)), + Set(Dog("rex", 2.0)), ) @Benchmark @@ -25,6 +32,16 @@ class DiffBench { bh.consume(Big.diff.diff(big, bigClone)) } + @Benchmark + def usingDiffObtainedOnly(bh: Blackhole): Unit = { + bh.consume(Big.diff.diff(DiffInput.ObtainedOnly(big))) + } + + @Benchmark + def usingDiffExpectedOnly(bh: Blackhole): Unit = { + bh.consume(Big.diff.diff(DiffInput.ExpectedOnly(bigClone))) + } + @Benchmark def usingEquals(bh: Blackhole): Unit = { bh.consume(big == bigClone) @@ -34,9 +51,9 @@ class DiffBench { final case class Big( i: Int, s: String, - // map: Map[Key, Dog], - // list: Vector[Dog], - // set: Set[Dog], + map: Map[Key, Dog], + list: Vector[Dog], + set: Set[Dog], ) object Big { @@ -48,7 +65,15 @@ final case class Dog( age: Double, ) +object Dog { + implicit val diff: Differ[Dog] = Differ.derived[Dog] +} + final case class Key( name: String, x: Int, ) + +object Key { + implicit val diff: ValueDiffer[Key] = Differ.useEquals[Key](_.toString) +} diff --git a/modules/core/src/main/scala/difflicious/DifferDerivationMacros.scala b/modules/core/src/main/scala/difflicious/DifferDerivationMacros.scala index 8fd8396..73ab9f2 100644 --- a/modules/core/src/main/scala/difflicious/DifferDerivationMacros.scala +++ b/modules/core/src/main/scala/difflicious/DifferDerivationMacros.scala @@ -6,7 +6,6 @@ import hearth.fp.effect.* import hearth.fp.instances.* import hearth.fp.syntax.* -import scala.collection.immutable.ListMap import scala.util.control.NoStackTrace private[difflicious] trait DifferDerivationMacros { this: hearth.MacroCommons => @@ -85,19 +84,15 @@ private[difflicious] trait DifferDerivationMacros { this: hearth.MacroCommons => field.value.asInstanceOf[Method[A, Field]].isConstructorArgument } - val fields = constructorFields.zipWithIndex.toList.parTraverse { case (field, index) => + val fields = constructorFields.toList.parTraverse { field => import field.Underlying as Field val fieldName = decodedName(field.value.name) - val getter = productGetterFor[A](index) summonFieldDiffer[A, Field](deriveIfMissing).map { differ => Expr.quote { Tuple2( Expr.splice(Expr(fieldName)), - Tuple2( - Expr.splice(getter), - Expr.splice(differ).asInstanceOf[difflicious.Differ[Any]], - ), + Expr.splice(differ).asInstanceOf[difflicious.Differ[Any]], ) } } @@ -105,8 +100,8 @@ private[difflicious] trait DifferDerivationMacros { this: hearth.MacroCommons => fields.map { fields => Expr.quote { - new difflicious.differ.RecordDiffer[A]( - fieldDiffers = Expr.splice(listMapExpr[A](fields)), + new difflicious.differ.ProductDiffer[A]( + fieldDiffers = Expr.splice(fieldDiffersExpr(fields)), isIgnored = false, typeName = Expr.splice(typeNameExpr[A]), ) @@ -642,19 +637,15 @@ private[difflicious] trait DifferDerivationMacros { this: hearth.MacroCommons => renderDerivationErrorLines(errors, s"$indent ") } - private def productGetterFor[A: Type](index: Int): Expr[A => Any] = - Expr.quote { (value: A) => - value.asInstanceOf[scala.Product].productElement(Expr.splice(Expr(index))) - } + private def fieldDiffersExpr( + fields: List[Expr[(String, Differ[Any])]], + ): Expr[Vector[(String, Differ[Any])]] = { + implicit val fieldDifferPair: Type[(String, Differ[Any])] = fieldDifferPairType - private def listMapExpr[A: Type]( - fields: List[Expr[(String, (A => Any, Differ[Any]))]], - ): Expr[ListMap[String, (A => Any, Differ[Any])]] = - fields.foldLeft(Expr.quote(ListMap.empty[String, (A => Any, difflicious.Differ[Any])])) { (acc, field) => - Expr.quote { - Expr.splice(acc) + Expr.splice(field) - } + Expr.quote { + Vector(Expr.splice(VarArgs(fields*))*) } + } private def vectorExpr[A: Type]( cases: List[Expr[OneOfDiffer.Case[A, Any]]], @@ -693,6 +684,9 @@ private[difflicious] trait DifferDerivationMacros { this: hearth.MacroCommons => private def oneOfCaseTypeInstance[A: Type]: Type[OneOfDiffer.Case[A, Any]] = Type.of[OneOfDiffer.Case[A, Any]] + private def fieldDifferPairType: Type[(String, Differ[Any])] = + Type.of[(String, Differ[Any])] + private def derivationCacheKey[A: Type]: String = s"${Type[A].plainPrint}" diff --git a/modules/core/src/main/scala/difflicious/PairType.scala b/modules/core/src/main/scala/difflicious/PairType.scala index 6bd181e..3f6e7b8 100644 --- a/modules/core/src/main/scala/difflicious/PairType.scala +++ b/modules/core/src/main/scala/difflicious/PairType.scala @@ -3,7 +3,9 @@ package difflicious sealed trait PairType object PairType { + sealed trait ObtainedOrExpected extends PairType + case object Both extends PairType - case object ObtainedOnly extends PairType - case object ExpectedOnly extends PairType + case object ObtainedOnly extends PairType with ObtainedOrExpected + case object ExpectedOnly extends PairType with ObtainedOrExpected } diff --git a/modules/core/src/main/scala/difflicious/differ/ProductDiffer.scala b/modules/core/src/main/scala/difflicious/differ/ProductDiffer.scala new file mode 100644 index 0000000..4263919 --- /dev/null +++ b/modules/core/src/main/scala/difflicious/differ/ProductDiffer.scala @@ -0,0 +1,112 @@ +package difflicious.differ + +import difflicious.* +import difflicious.utils.TypeName.SomeTypeName + +import scala.collection.immutable.ListMap + +/** A differ for product data structures such as tuples and case classes. + */ +final class ProductDiffer[T]( + fieldDiffers: Vector[(String, Differ[Any])], + isIgnored: Boolean, + typeName: SomeTypeName, +) extends Differ[T] { + override type R = DiffResult.RecordResult + + override def diff(inputs: DiffInput[T]): R = inputs match { + case DiffInput.Both(obtained, expected) => + val obtainedProduct = obtained.asInstanceOf[Product] + val expectedProduct = expected.asInstanceOf[Product] + val diffResultsBuilder = ListMap.newBuilder[String, DiffResult] + var isOk = true + var index = 0 + val fieldCount = fieldDiffers.size + + while (index < fieldCount) { + val fieldDiffer = fieldDiffers(index) + val diffResult = + fieldDiffer._2.diff(obtainedProduct.productElement(index), expectedProduct.productElement(index)) + diffResultsBuilder += fieldDiffer._1 -> diffResult + if (!diffResult.isOk) isOk = false + index += 1 + } + + val diffResults = diffResultsBuilder.result() + DiffResult + .RecordResult( + typeName = typeName, + fields = diffResults, + pairType = PairType.Both, + isIgnored = isIgnored, + isOk = isIgnored || isOk, + ) + case DiffInput.ObtainedOnly(value) => + calcDiffResultForOneSide( + product = value.asInstanceOf[Product], + pairType = PairType.ObtainedOnly, + ) + case DiffInput.ExpectedOnly(expected) => + calcDiffResultForOneSide( + product = expected.asInstanceOf[Product], + pairType = PairType.ExpectedOnly, + ) + } + + private def calcDiffResultForOneSide( + product: Product, + pairType: PairType.ObtainedOrExpected, + ): R = { + val diffResultsBuilder = ListMap.newBuilder[String, DiffResult] + var index = 0 + val fieldCount = fieldDiffers.size + + while (index < fieldCount) { + val fieldDiffer = fieldDiffers(index) + val fieldValue = product.productElement(index) + val diffInput: DiffInput[Any] = pairType match { + case PairType.ObtainedOnly => DiffInput.ObtainedOnly(fieldValue) + case PairType.ExpectedOnly => DiffInput.ExpectedOnly(fieldValue) + } + val diffResult = fieldDiffer._2.diff(diffInput) + diffResultsBuilder += fieldDiffer._1 -> diffResult + index += 1 + } + + DiffResult + .RecordResult( + typeName = typeName, + fields = diffResultsBuilder.result(), + pairType = pairType, + isIgnored = isIgnored, + isOk = isIgnored, + ) + } + + override def configureIgnored(newIgnored: Boolean): Differ[T] = + new ProductDiffer[T](fieldDiffers = fieldDiffers, isIgnored = newIgnored, typeName = typeName) + + override def configurePath( + step: String, + nextPath: ConfigurePath, + op: ConfigureOp, + ): Either[ConfigureError, Differ[T]] = { + val index = fieldDiffers.indexWhere(_._1 == step) + + if (index < 0) { + Left(ConfigureError.NonExistentField(nextPath, "ProductDiffer")) + } else { + val (fieldName, fieldDiffer) = fieldDiffers(index) + fieldDiffer.configureRaw(nextPath, op).map { newFieldDiffer => + new ProductDiffer[T]( + fieldDiffers = fieldDiffers.updated(index, (fieldName, newFieldDiffer)), + isIgnored = isIgnored, + typeName = typeName, + ) + } + } + } + + override def configurePairBy(path: ConfigurePath, op: ConfigureOp.PairBy[?]): Either[ConfigureError, Differ[T]] = + Left(ConfigureError.InvalidConfigureOp(path, op, "ProductDiffer")) +} diff --git a/modules/coretest/src/test/resources/snapshots/scala-2.13/DifferDerivationTreeSpec/derived-recursive-tree.scala b/modules/coretest/src/test/resources/snapshots/scala-2.13/DifferDerivationTreeSpec/derived-recursive-tree.scala index f843c28..0452388 100644 --- a/modules/coretest/src/test/resources/snapshots/scala-2.13/DifferDerivationTreeSpec/derived-recursive-tree.scala +++ b/modules/coretest/src/test/resources/snapshots/scala-2.13/DifferDerivationTreeSpec/derived-recursive-tree.scala @@ -1,4 +1,4 @@ { - lazy val derivedDiffer$macro$4: difflicious.Differ[difflicious.testtypes.RecursiveDerivedNode] = new difflicious.differ.LazyDiffer[difflicious.testtypes.RecursiveDerivedNode](new difflicious.differ.RecordDiffer[difflicious.testtypes.RecursiveDerivedNode](ListMap.empty[String, Tuple2[Function1[difflicious.testtypes.RecursiveDerivedNode, Any], difflicious.Differ[Any]]].+[Tuple2[Function1[difflicious.testtypes.RecursiveDerivedNode, Any], difflicious.Differ[Any]]](Tuple2.apply[String, Tuple2[Function1[difflicious.testtypes.RecursiveDerivedNode, Any], difflicious.Differ[Any]]]("value", Tuple2.apply[Function1[difflicious.testtypes.RecursiveDerivedNode, Any], difflicious.Differ[Any]](((value: difflicious.testtypes.RecursiveDerivedNode) => value.asInstanceOf[Product].productElement(0)), difflicious.Differ.stringDiffer.asInstanceOf[difflicious.Differ[Any]]))).+[Tuple2[Function1[difflicious.testtypes.RecursiveDerivedNode, Any], difflicious.Differ[Any]]](Tuple2.apply[String, Tuple2[Function1[difflicious.testtypes.RecursiveDerivedNode, Any], difflicious.Differ[Any]]]("children", Tuple2.apply[Function1[difflicious.testtypes.RecursiveDerivedNode, Any], difflicious.Differ[Any]](((value: difflicious.testtypes.RecursiveDerivedNode) => value.asInstanceOf[Product].productElement(1)), new difflicious.differ.SeqDiffer[List,difflicious.testtypes.RecursiveDerivedNode](false, difflicious.ConfigureOp.PairBy.Index, derivedDiffer$macro$4, difflicious.utils.TypeName.apply[List[difflicious.testtypes.RecursiveDerivedNode]](/*irrelevant*/), difflicious.utils.SeqLike.stdSeqAsSeq[[+A]List[A]]).asInstanceOf[difflicious.Differ[Any]]))), false, difflicious.utils.TypeName.apply[Any]("difflicious.testtypes.RecursiveDerivedNode", "RecursiveDerivedNode", Nil))); + lazy val derivedDiffer$macro$4: difflicious.Differ[difflicious.testtypes.RecursiveDerivedNode] = new difflicious.differ.LazyDiffer[difflicious.testtypes.RecursiveDerivedNode](new difflicious.differ.ProductDiffer[difflicious.testtypes.RecursiveDerivedNode](Vector.apply[Tuple2[String, difflicious.Differ[Any]]](Tuple2.apply[String, difflicious.Differ[Any]]("value", difflicious.Differ.stringDiffer.asInstanceOf[difflicious.Differ[Any]]), Tuple2.apply[String, difflicious.Differ[Any]]("children", new difflicious.differ.SeqDiffer[List,difflicious.testtypes.RecursiveDerivedNode](false, difflicious.ConfigureOp.PairBy.Index, derivedDiffer$macro$4, difflicious.utils.TypeName.apply[List[difflicious.testtypes.RecursiveDerivedNode]](/*irrelevant*/), difflicious.utils.SeqLike.stdSeqAsSeq[[+A]List[A]]).asInstanceOf[difflicious.Differ[Any]])), false, difflicious.utils.TypeName.apply[Any]("difflicious.testtypes.RecursiveDerivedNode", "RecursiveDerivedNode", Nil))); derivedDiffer$macro$4 } diff --git a/modules/coretest/src/test/resources/snapshots/scala-2.13/DifferDerivationTreeSpec/derivedDeep-recursive-tree.scala b/modules/coretest/src/test/resources/snapshots/scala-2.13/DifferDerivationTreeSpec/derivedDeep-recursive-tree.scala index fc69710..8d2b79b 100644 --- a/modules/coretest/src/test/resources/snapshots/scala-2.13/DifferDerivationTreeSpec/derivedDeep-recursive-tree.scala +++ b/modules/coretest/src/test/resources/snapshots/scala-2.13/DifferDerivationTreeSpec/derivedDeep-recursive-tree.scala @@ -1,4 +1,4 @@ { - lazy val derivedDiffer$macro$5: difflicious.Differ[difflicious.testtypes.RecursiveDerivedDeepNode] = new difflicious.differ.LazyDiffer[difflicious.testtypes.RecursiveDerivedDeepNode](new difflicious.differ.RecordDiffer[difflicious.testtypes.RecursiveDerivedDeepNode](ListMap.empty[String, Tuple2[Function1[difflicious.testtypes.RecursiveDerivedDeepNode, Any], difflicious.Differ[Any]]].+[Tuple2[Function1[difflicious.testtypes.RecursiveDerivedDeepNode, Any], difflicious.Differ[Any]]](Tuple2.apply[String, Tuple2[Function1[difflicious.testtypes.RecursiveDerivedDeepNode, Any], difflicious.Differ[Any]]]("value", Tuple2.apply[Function1[difflicious.testtypes.RecursiveDerivedDeepNode, Any], difflicious.Differ[Any]](((value: difflicious.testtypes.RecursiveDerivedDeepNode) => value.asInstanceOf[Product].productElement(0)), difflicious.Differ.stringDiffer.asInstanceOf[difflicious.Differ[Any]]))).+[Tuple2[Function1[difflicious.testtypes.RecursiveDerivedDeepNode, Any], difflicious.Differ[Any]]](Tuple2.apply[String, Tuple2[Function1[difflicious.testtypes.RecursiveDerivedDeepNode, Any], difflicious.Differ[Any]]]("children", Tuple2.apply[Function1[difflicious.testtypes.RecursiveDerivedDeepNode, Any], difflicious.Differ[Any]](((value: difflicious.testtypes.RecursiveDerivedDeepNode) => value.asInstanceOf[Product].productElement(1)), new difflicious.differ.SeqDiffer[List,difflicious.testtypes.RecursiveDerivedDeepNode](false, difflicious.ConfigureOp.PairBy.Index, derivedDiffer$macro$5, difflicious.utils.TypeName.apply[List[difflicious.testtypes.RecursiveDerivedDeepNode]](/*irrelevant*/), difflicious.utils.SeqLike.stdSeqAsSeq[[+A]List[A]]).asInstanceOf[difflicious.Differ[Any]]))), false, difflicious.utils.TypeName.apply[Any]("difflicious.testtypes.RecursiveDerivedDeepNode", "RecursiveDerivedDeepNode", Nil))); + lazy val derivedDiffer$macro$5: difflicious.Differ[difflicious.testtypes.RecursiveDerivedDeepNode] = new difflicious.differ.LazyDiffer[difflicious.testtypes.RecursiveDerivedDeepNode](new difflicious.differ.ProductDiffer[difflicious.testtypes.RecursiveDerivedDeepNode](Vector.apply[Tuple2[String, difflicious.Differ[Any]]](Tuple2.apply[String, difflicious.Differ[Any]]("value", difflicious.Differ.stringDiffer.asInstanceOf[difflicious.Differ[Any]]), Tuple2.apply[String, difflicious.Differ[Any]]("children", new difflicious.differ.SeqDiffer[List,difflicious.testtypes.RecursiveDerivedDeepNode](false, difflicious.ConfigureOp.PairBy.Index, derivedDiffer$macro$5, difflicious.utils.TypeName.apply[List[difflicious.testtypes.RecursiveDerivedDeepNode]](/*irrelevant*/), difflicious.utils.SeqLike.stdSeqAsSeq[[+A]List[A]]).asInstanceOf[difflicious.Differ[Any]])), false, difflicious.utils.TypeName.apply[Any]("difflicious.testtypes.RecursiveDerivedDeepNode", "RecursiveDerivedDeepNode", Nil))); derivedDiffer$macro$5 } diff --git a/modules/coretest/src/test/resources/snapshots/scala-2.13/DifferDerivationTreeSpec/derivedDeep-tree.scala b/modules/coretest/src/test/resources/snapshots/scala-2.13/DifferDerivationTreeSpec/derivedDeep-tree.scala index c587fec..87573c4 100644 --- a/modules/coretest/src/test/resources/snapshots/scala-2.13/DifferDerivationTreeSpec/derivedDeep-tree.scala +++ b/modules/coretest/src/test/resources/snapshots/scala-2.13/DifferDerivationTreeSpec/derivedDeep-tree.scala @@ -1,15 +1,15 @@ { - lazy val derivedDiffer$macro$2: difflicious.Differ[difflicious.testtypes.TreeContainer] = new difflicious.differ.LazyDiffer[difflicious.testtypes.TreeContainer](new difflicious.differ.RecordDiffer[difflicious.testtypes.TreeContainer](ListMap.empty[String, Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]].+[Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]](Tuple2.apply[String, Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]]("c1", Tuple2.apply[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]](((value: difflicious.testtypes.TreeContainer) => value.asInstanceOf[Product].productElement(0)), d1.asInstanceOf[difflicious.Differ[Any]]))).+[Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]](Tuple2.apply[String, Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]]("c2", Tuple2.apply[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]](((value: difflicious.testtypes.TreeContainer) => value.asInstanceOf[Product].productElement(1)), derivedDiffer$macro$3.asInstanceOf[difflicious.Differ[Any]]))).+[Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]](Tuple2.apply[String, Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]]("option", Tuple2.apply[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]](((value: difflicious.testtypes.TreeContainer) => value.asInstanceOf[Product].productElement(2)), ({ + lazy val derivedDiffer$macro$2: difflicious.Differ[difflicious.testtypes.TreeContainer] = new difflicious.differ.LazyDiffer[difflicious.testtypes.TreeContainer](new difflicious.differ.ProductDiffer[difflicious.testtypes.TreeContainer](Vector.apply[Tuple2[String, difflicious.Differ[Any]]](Tuple2.apply[String, difflicious.Differ[Any]]("c1", d1.asInstanceOf[difflicious.Differ[Any]]), Tuple2.apply[String, difflicious.Differ[Any]]("c2", derivedDiffer$macro$3.asInstanceOf[difflicious.Differ[Any]]), Tuple2.apply[String, difflicious.Differ[Any]]("option", ({ implicit val valueDiffer: difflicious.Differ[difflicious.testtypes.TreeCaseClass2] = derivedDiffer$macro$3; difflicious.Differ.optionDiffer[difflicious.testtypes.TreeCaseClass2](valueDiffer) -}).asInstanceOf[difflicious.Differ[Any]]))).+[Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]](Tuple2.apply[String, Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]]("either", Tuple2.apply[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]](((value: difflicious.testtypes.TreeContainer) => value.asInstanceOf[Product].productElement(3)), ({ +}).asInstanceOf[difflicious.Differ[Any]]), Tuple2.apply[String, difflicious.Differ[Any]]("either", ({ implicit val leftValueDiffer: difflicious.Differ[difflicious.testtypes.TreeCaseClass1] = d1; implicit val rightValueDiffer: difflicious.Differ[difflicious.testtypes.TreeCaseClass2] = derivedDiffer$macro$3; difflicious.Differ.eitherDiffer[difflicious.testtypes.TreeCaseClass1, difflicious.testtypes.TreeCaseClass2](leftValueDiffer, rightValueDiffer) -}).asInstanceOf[difflicious.Differ[Any]]))).+[Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]](Tuple2.apply[String, Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]]("map", Tuple2.apply[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]](((value: difflicious.testtypes.TreeContainer) => value.asInstanceOf[Product].productElement(4)), new difflicious.differ.MapDiffer[Map,String,difflicious.testtypes.TreeCaseClass2](false, difflicious.Differ.stringDiffer, derivedDiffer$macro$3, difflicious.utils.TypeName.apply[Map[String,difflicious.testtypes.TreeCaseClass2]](/*irrelevant*/), difflicious.utils.MapLike.stdMapAsMap[[K, +V]Map[K,V]]).asInstanceOf[difflicious.Differ[Any]]))).+[Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]](Tuple2.apply[String, Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]]("list", Tuple2.apply[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]](((value: difflicious.testtypes.TreeContainer) => value.asInstanceOf[Product].productElement(5)), new difflicious.differ.SeqDiffer[List,Option[difflicious.testtypes.TreeCaseClass2]](false, difflicious.ConfigureOp.PairBy.Index, { +}).asInstanceOf[difflicious.Differ[Any]]), Tuple2.apply[String, difflicious.Differ[Any]]("map", new difflicious.differ.MapDiffer[Map,String,difflicious.testtypes.TreeCaseClass2](false, difflicious.Differ.stringDiffer, derivedDiffer$macro$3, difflicious.utils.TypeName.apply[Map[String,difflicious.testtypes.TreeCaseClass2]](/*irrelevant*/), difflicious.utils.MapLike.stdMapAsMap[[K, +V]Map[K,V]]).asInstanceOf[difflicious.Differ[Any]]), Tuple2.apply[String, difflicious.Differ[Any]]("list", new difflicious.differ.SeqDiffer[List,Option[difflicious.testtypes.TreeCaseClass2]](false, difflicious.ConfigureOp.PairBy.Index, { implicit val valueDiffer: difflicious.Differ[difflicious.testtypes.TreeCaseClass2] = derivedDiffer$macro$3; difflicious.Differ.optionDiffer[difflicious.testtypes.TreeCaseClass2](valueDiffer) -}, difflicious.utils.TypeName.apply[List[Option[difflicious.testtypes.TreeCaseClass2]]](/*irrelevant*/), difflicious.utils.SeqLike.stdSeqAsSeq[[+A]List[A]]).asInstanceOf[difflicious.Differ[Any]]))), false, difflicious.utils.TypeName.apply[Any]("difflicious.testtypes.TreeContainer", "TreeContainer", Nil))); - lazy val derivedDiffer$macro$3: difflicious.Differ[difflicious.testtypes.TreeCaseClass2] = new difflicious.differ.LazyDiffer[difflicious.testtypes.TreeCaseClass2](new difflicious.differ.RecordDiffer[difflicious.testtypes.TreeCaseClass2](ListMap.empty[String, Tuple2[Function1[difflicious.testtypes.TreeCaseClass2, Any], difflicious.Differ[Any]]].+[Tuple2[Function1[difflicious.testtypes.TreeCaseClass2, Any], difflicious.Differ[Any]]](Tuple2.apply[String, Tuple2[Function1[difflicious.testtypes.TreeCaseClass2, Any], difflicious.Differ[Any]]]("value", Tuple2.apply[Function1[difflicious.testtypes.TreeCaseClass2, Any], difflicious.Differ[Any]](((value: difflicious.testtypes.TreeCaseClass2) => value.asInstanceOf[Product].productElement(0)), difflicious.Differ.stringDiffer.asInstanceOf[difflicious.Differ[Any]]))), false, difflicious.utils.TypeName.apply[Any]("difflicious.testtypes.TreeCaseClass2", "TreeCaseClass2", Nil))); +}, difflicious.utils.TypeName.apply[List[Option[difflicious.testtypes.TreeCaseClass2]]](/*irrelevant*/), difflicious.utils.SeqLike.stdSeqAsSeq[[+A]List[A]]).asInstanceOf[difflicious.Differ[Any]])), false, difflicious.utils.TypeName.apply[Any]("difflicious.testtypes.TreeContainer", "TreeContainer", Nil))); + lazy val derivedDiffer$macro$3: difflicious.Differ[difflicious.testtypes.TreeCaseClass2] = new difflicious.differ.LazyDiffer[difflicious.testtypes.TreeCaseClass2](new difflicious.differ.ProductDiffer[difflicious.testtypes.TreeCaseClass2](Vector.apply[Tuple2[String, difflicious.Differ[Any]]](Tuple2.apply[String, difflicious.Differ[Any]]("value", difflicious.Differ.stringDiffer.asInstanceOf[difflicious.Differ[Any]])), false, difflicious.utils.TypeName.apply[Any]("difflicious.testtypes.TreeCaseClass2", "TreeCaseClass2", Nil))); derivedDiffer$macro$2 } diff --git a/modules/coretest/src/test/resources/snapshots/scala-3/DifferDerivationTreeSpec/derived-recursive-tree.scala b/modules/coretest/src/test/resources/snapshots/scala-3/DifferDerivationTreeSpec/derived-recursive-tree.scala index b44ba91..23f7243 100644 --- a/modules/coretest/src/test/resources/snapshots/scala-3/DifferDerivationTreeSpec/derived-recursive-tree.scala +++ b/modules/coretest/src/test/resources/snapshots/scala-3/DifferDerivationTreeSpec/derived-recursive-tree.scala @@ -2,7 +2,7 @@ val DifferGen_this: difflicious.Differ.type = difflicious.Differ ({ - lazy val derivedDiffer$macro$4: difflicious.Differ[difflicious.testtypes.RecursiveDerivedNode] = new difflicious.differ.LazyDiffer[difflicious.testtypes.RecursiveDerivedNode](new difflicious.differ.RecordDiffer[difflicious.testtypes.RecursiveDerivedNode](fieldDiffers = ListMap.empty[String, Tuple2[Function1[difflicious.testtypes.RecursiveDerivedNode, Any], difflicious.Differ[Any]]].+[Tuple2[Function1[difflicious.testtypes.RecursiveDerivedNode, Any], difflicious.Differ[Any]]](Tuple2.apply[String, Tuple2[Function1[difflicious.testtypes.RecursiveDerivedNode, Any], difflicious.Differ[Any]]]("value", Tuple2.apply[Function1[difflicious.testtypes.RecursiveDerivedNode, Any], difflicious.Differ[Any]](((value: difflicious.testtypes.RecursiveDerivedNode) => value.asInstanceOf[Product].productElement(0)), difflicious.Differ.stringDiffer.asInstanceOf[difflicious.Differ[Any]]))).+[Tuple2[Function1[difflicious.testtypes.RecursiveDerivedNode, Any], difflicious.Differ[Any]]](Tuple2.apply[String, Tuple2[Function1[difflicious.testtypes.RecursiveDerivedNode, Any], difflicious.Differ[Any]]]("children", Tuple2.apply[Function1[difflicious.testtypes.RecursiveDerivedNode, Any], difflicious.Differ[Any]](((`value₂`: difflicious.testtypes.RecursiveDerivedNode) => `value₂`.asInstanceOf[Product].productElement(1)), new difflicious.differ.SeqDiffer[List, difflicious.testtypes.RecursiveDerivedNode][[A >: Nothing <: Any] =>> List[A], difflicious.testtypes.RecursiveDerivedNode](false, difflicious.ConfigureOp.PairBy.Index, derivedDiffer$macro$4, difflicious.utils.TypeName.apply[List[difflicious.testtypes.RecursiveDerivedNode]](/*irrelevant*/), difflicious.utils.SeqLike.stdSeqAsSeq[[A >: Nothing <: Any] =>> List[A]]).asInstanceOf[difflicious.Differ[Any]]))), isIgnored = false, typeName = difflicious.utils.TypeName.apply[Any](long = "difflicious.testtypes.RecursiveDerivedNode", short = "RecursiveDerivedNode", typeArguments = Nil))) + lazy val derivedDiffer$macro$4: difflicious.Differ[difflicious.testtypes.RecursiveDerivedNode] = new difflicious.differ.LazyDiffer[difflicious.testtypes.RecursiveDerivedNode](new difflicious.differ.ProductDiffer[difflicious.testtypes.RecursiveDerivedNode](fieldDiffers = scala.Vector.apply[Tuple2[String, difflicious.Differ[Any]]](Tuple2.apply[String, difflicious.Differ[Any]]("value", difflicious.Differ.stringDiffer.asInstanceOf[difflicious.Differ[Any]]), Tuple2.apply[String, difflicious.Differ[Any]]("children", new difflicious.differ.SeqDiffer[List, difflicious.testtypes.RecursiveDerivedNode][[A >: Nothing <: Any] =>> List[A], difflicious.testtypes.RecursiveDerivedNode](false, difflicious.ConfigureOp.PairBy.Index, derivedDiffer$macro$4, difflicious.utils.TypeName.apply[List[difflicious.testtypes.RecursiveDerivedNode]](/*irrelevant*/), difflicious.utils.SeqLike.stdSeqAsSeq[[A >: Nothing <: Any] =>> List[A]]).asInstanceOf[difflicious.Differ[Any]])), isIgnored = false, typeName = difflicious.utils.TypeName.apply[Any](long = "difflicious.testtypes.RecursiveDerivedNode", short = "RecursiveDerivedNode", typeArguments = Nil))) (derivedDiffer$macro$4: difflicious.Differ[difflicious.testtypes.RecursiveDerivedNode]) }: difflicious.Differ[difflicious.testtypes.RecursiveDerivedNode]) diff --git a/modules/coretest/src/test/resources/snapshots/scala-3/DifferDerivationTreeSpec/derivedDeep-recursive-tree.scala b/modules/coretest/src/test/resources/snapshots/scala-3/DifferDerivationTreeSpec/derivedDeep-recursive-tree.scala index b9213e7..17053ee 100644 --- a/modules/coretest/src/test/resources/snapshots/scala-3/DifferDerivationTreeSpec/derivedDeep-recursive-tree.scala +++ b/modules/coretest/src/test/resources/snapshots/scala-3/DifferDerivationTreeSpec/derivedDeep-recursive-tree.scala @@ -2,7 +2,7 @@ val DifferGen_this: difflicious.Differ.type = difflicious.Differ ({ - lazy val derivedDiffer$macro$5: difflicious.Differ[difflicious.testtypes.RecursiveDerivedDeepNode] = new difflicious.differ.LazyDiffer[difflicious.testtypes.RecursiveDerivedDeepNode](new difflicious.differ.RecordDiffer[difflicious.testtypes.RecursiveDerivedDeepNode](fieldDiffers = ListMap.empty[String, Tuple2[Function1[difflicious.testtypes.RecursiveDerivedDeepNode, Any], difflicious.Differ[Any]]].+[Tuple2[Function1[difflicious.testtypes.RecursiveDerivedDeepNode, Any], difflicious.Differ[Any]]](Tuple2.apply[String, Tuple2[Function1[difflicious.testtypes.RecursiveDerivedDeepNode, Any], difflicious.Differ[Any]]]("value", Tuple2.apply[Function1[difflicious.testtypes.RecursiveDerivedDeepNode, Any], difflicious.Differ[Any]](((value: difflicious.testtypes.RecursiveDerivedDeepNode) => value.asInstanceOf[Product].productElement(0)), difflicious.Differ.stringDiffer.asInstanceOf[difflicious.Differ[Any]]))).+[Tuple2[Function1[difflicious.testtypes.RecursiveDerivedDeepNode, Any], difflicious.Differ[Any]]](Tuple2.apply[String, Tuple2[Function1[difflicious.testtypes.RecursiveDerivedDeepNode, Any], difflicious.Differ[Any]]]("children", Tuple2.apply[Function1[difflicious.testtypes.RecursiveDerivedDeepNode, Any], difflicious.Differ[Any]](((`value₂`: difflicious.testtypes.RecursiveDerivedDeepNode) => `value₂`.asInstanceOf[Product].productElement(1)), new difflicious.differ.SeqDiffer[List, difflicious.testtypes.RecursiveDerivedDeepNode][[A >: Nothing <: Any] =>> List[A], difflicious.testtypes.RecursiveDerivedDeepNode](false, difflicious.ConfigureOp.PairBy.Index, derivedDiffer$macro$5, difflicious.utils.TypeName.apply[List[difflicious.testtypes.RecursiveDerivedDeepNode]](/*irrelevant*/), difflicious.utils.SeqLike.stdSeqAsSeq[[A >: Nothing <: Any] =>> List[A]]).asInstanceOf[difflicious.Differ[Any]]))), isIgnored = false, typeName = difflicious.utils.TypeName.apply[Any](long = "difflicious.testtypes.RecursiveDerivedDeepNode", short = "RecursiveDerivedDeepNode", typeArguments = Nil))) + lazy val derivedDiffer$macro$5: difflicious.Differ[difflicious.testtypes.RecursiveDerivedDeepNode] = new difflicious.differ.LazyDiffer[difflicious.testtypes.RecursiveDerivedDeepNode](new difflicious.differ.ProductDiffer[difflicious.testtypes.RecursiveDerivedDeepNode](fieldDiffers = scala.Vector.apply[Tuple2[String, difflicious.Differ[Any]]](Tuple2.apply[String, difflicious.Differ[Any]]("value", difflicious.Differ.stringDiffer.asInstanceOf[difflicious.Differ[Any]]), Tuple2.apply[String, difflicious.Differ[Any]]("children", new difflicious.differ.SeqDiffer[List, difflicious.testtypes.RecursiveDerivedDeepNode][[A >: Nothing <: Any] =>> List[A], difflicious.testtypes.RecursiveDerivedDeepNode](false, difflicious.ConfigureOp.PairBy.Index, derivedDiffer$macro$5, difflicious.utils.TypeName.apply[List[difflicious.testtypes.RecursiveDerivedDeepNode]](/*irrelevant*/), difflicious.utils.SeqLike.stdSeqAsSeq[[A >: Nothing <: Any] =>> List[A]]).asInstanceOf[difflicious.Differ[Any]])), isIgnored = false, typeName = difflicious.utils.TypeName.apply[Any](long = "difflicious.testtypes.RecursiveDerivedDeepNode", short = "RecursiveDerivedDeepNode", typeArguments = Nil))) (derivedDiffer$macro$5: difflicious.Differ[difflicious.testtypes.RecursiveDerivedDeepNode]) }: difflicious.Differ[difflicious.testtypes.RecursiveDerivedDeepNode]) diff --git a/modules/coretest/src/test/resources/snapshots/scala-3/DifferDerivationTreeSpec/derivedDeep-tree.scala b/modules/coretest/src/test/resources/snapshots/scala-3/DifferDerivationTreeSpec/derivedDeep-tree.scala index 325a546..cc8e05a 100644 --- a/modules/coretest/src/test/resources/snapshots/scala-3/DifferDerivationTreeSpec/derivedDeep-tree.scala +++ b/modules/coretest/src/test/resources/snapshots/scala-3/DifferDerivationTreeSpec/derivedDeep-tree.scala @@ -2,18 +2,18 @@ val DifferGen_this: difflicious.Differ.type = difflicious.Differ ({ - lazy val derivedDiffer$macro$2: difflicious.Differ[difflicious.testtypes.TreeContainer] = new difflicious.differ.LazyDiffer[difflicious.testtypes.TreeContainer](new difflicious.differ.RecordDiffer[difflicious.testtypes.TreeContainer](fieldDiffers = ListMap.empty[String, Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]].+[Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]](Tuple2.apply[String, Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]]("c1", Tuple2.apply[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]](((value: difflicious.testtypes.TreeContainer) => value.asInstanceOf[Product].productElement(0)), d1.asInstanceOf[difflicious.Differ[Any]]))).+[Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]](Tuple2.apply[String, Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]]("c2", Tuple2.apply[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]](((`value₂`: difflicious.testtypes.TreeContainer) => `value₂`.asInstanceOf[Product].productElement(1)), derivedDiffer$macro$3.asInstanceOf[difflicious.Differ[Any]]))).+[Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]](Tuple2.apply[String, Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]]("option", Tuple2.apply[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]](((`value₃`: difflicious.testtypes.TreeContainer) => `value₃`.asInstanceOf[Product].productElement(2)), { + lazy val derivedDiffer$macro$2: difflicious.Differ[difflicious.testtypes.TreeContainer] = new difflicious.differ.LazyDiffer[difflicious.testtypes.TreeContainer](new difflicious.differ.ProductDiffer[difflicious.testtypes.TreeContainer](fieldDiffers = scala.Vector.apply[Tuple2[String, difflicious.Differ[Any]]](Tuple2.apply[String, difflicious.Differ[Any]]("c1", d1.asInstanceOf[difflicious.Differ[Any]]), Tuple2.apply[String, difflicious.Differ[Any]]("c2", derivedDiffer$macro$3.asInstanceOf[difflicious.Differ[Any]]), Tuple2.apply[String, difflicious.Differ[Any]]("option", { implicit val valueDiffer: difflicious.Differ[difflicious.testtypes.TreeCaseClass2] = derivedDiffer$macro$3 difflicious.Differ.optionDiffer[difflicious.testtypes.TreeCaseClass2](valueDiffer) - }.asInstanceOf[difflicious.Differ[Any]]))).+[Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]](Tuple2.apply[String, Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]]("either", Tuple2.apply[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]](((`value₄`: difflicious.testtypes.TreeContainer) => `value₄`.asInstanceOf[Product].productElement(3)), { + }.asInstanceOf[difflicious.Differ[Any]]), Tuple2.apply[String, difflicious.Differ[Any]]("either", { implicit val leftValueDiffer: difflicious.Differ[difflicious.testtypes.TreeCaseClass1] = d1 implicit val rightValueDiffer: difflicious.Differ[difflicious.testtypes.TreeCaseClass2] = derivedDiffer$macro$3 difflicious.Differ.eitherDiffer[difflicious.testtypes.TreeCaseClass1, difflicious.testtypes.TreeCaseClass2](leftValueDiffer, rightValueDiffer) - }.asInstanceOf[difflicious.Differ[Any]]))).+[Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]](Tuple2.apply[String, Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]]("map", Tuple2.apply[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]](((`value₅`: difflicious.testtypes.TreeContainer) => `value₅`.asInstanceOf[Product].productElement(4)), new difflicious.differ.MapDiffer[Map, String, difflicious.testtypes.TreeCaseClass2][[K >: Nothing <: Any, V >: Nothing <: Any] =>> Map[K, V], String, difflicious.testtypes.TreeCaseClass2](false, difflicious.Differ.stringDiffer, derivedDiffer$macro$3, difflicious.utils.TypeName.apply[Map[String, difflicious.testtypes.TreeCaseClass2]](/*irrelevant*/), difflicious.utils.MapLike.stdMapAsMap[[K >: Nothing <: Any, V >: Nothing <: Any] =>> Map[K, V]]).asInstanceOf[difflicious.Differ[Any]]))).+[Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]](Tuple2.apply[String, Tuple2[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]]]("list", Tuple2.apply[Function1[difflicious.testtypes.TreeContainer, Any], difflicious.Differ[Any]](((`value₆`: difflicious.testtypes.TreeContainer) => `value₆`.asInstanceOf[Product].productElement(5)), new difflicious.differ.SeqDiffer[List, Option[difflicious.testtypes.TreeCaseClass2]][[A >: Nothing <: Any] =>> List[A], Option[difflicious.testtypes.TreeCaseClass2]](false, difflicious.ConfigureOp.PairBy.Index, { + }.asInstanceOf[difflicious.Differ[Any]]), Tuple2.apply[String, difflicious.Differ[Any]]("map", new difflicious.differ.MapDiffer[Map, String, difflicious.testtypes.TreeCaseClass2][[K >: Nothing <: Any, V >: Nothing <: Any] =>> Map[K, V], String, difflicious.testtypes.TreeCaseClass2](false, difflicious.Differ.stringDiffer, derivedDiffer$macro$3, difflicious.utils.TypeName.apply[Map[String, difflicious.testtypes.TreeCaseClass2]](/*irrelevant*/), difflicious.utils.MapLike.stdMapAsMap[[K >: Nothing <: Any, V >: Nothing <: Any] =>> Map[K, V]]).asInstanceOf[difflicious.Differ[Any]]), Tuple2.apply[String, difflicious.Differ[Any]]("list", new difflicious.differ.SeqDiffer[List, Option[difflicious.testtypes.TreeCaseClass2]][[A >: Nothing <: Any] =>> List[A], Option[difflicious.testtypes.TreeCaseClass2]](false, difflicious.ConfigureOp.PairBy.Index, { implicit val `valueDiffer₂`: difflicious.Differ[difflicious.testtypes.TreeCaseClass2] = derivedDiffer$macro$3 difflicious.Differ.optionDiffer[difflicious.testtypes.TreeCaseClass2](`valueDiffer₂`) - }, difflicious.utils.TypeName.apply[List[Option[difflicious.testtypes.TreeCaseClass2]]](/*irrelevant*/), difflicious.utils.SeqLike.stdSeqAsSeq[[A >: Nothing <: Any] =>> List[A]]).asInstanceOf[difflicious.Differ[Any]]))), isIgnored = false, typeName = difflicious.utils.TypeName.apply[Any](long = "difflicious.testtypes.TreeContainer", short = "TreeContainer", typeArguments = Nil))) - lazy val derivedDiffer$macro$3: difflicious.Differ[difflicious.testtypes.TreeCaseClass2] = new difflicious.differ.LazyDiffer[difflicious.testtypes.TreeCaseClass2](new difflicious.differ.RecordDiffer[difflicious.testtypes.TreeCaseClass2](fieldDiffers = ListMap.empty[String, Tuple2[Function1[difflicious.testtypes.TreeCaseClass2, Any], difflicious.Differ[Any]]].+[Tuple2[Function1[difflicious.testtypes.TreeCaseClass2, Any], difflicious.Differ[Any]]](Tuple2.apply[String, Tuple2[Function1[difflicious.testtypes.TreeCaseClass2, Any], difflicious.Differ[Any]]]("value", Tuple2.apply[Function1[difflicious.testtypes.TreeCaseClass2, Any], difflicious.Differ[Any]](((`value₇`: difflicious.testtypes.TreeCaseClass2) => `value₇`.asInstanceOf[Product].productElement(0)), difflicious.Differ.stringDiffer.asInstanceOf[difflicious.Differ[Any]]))), isIgnored = false, typeName = difflicious.utils.TypeName.apply[Any](long = "difflicious.testtypes.TreeCaseClass2", short = "TreeCaseClass2", typeArguments = Nil))) + }, difflicious.utils.TypeName.apply[List[Option[difflicious.testtypes.TreeCaseClass2]]](/*irrelevant*/), difflicious.utils.SeqLike.stdSeqAsSeq[[A >: Nothing <: Any] =>> List[A]]).asInstanceOf[difflicious.Differ[Any]])), isIgnored = false, typeName = difflicious.utils.TypeName.apply[Any](long = "difflicious.testtypes.TreeContainer", short = "TreeContainer", typeArguments = Nil))) + lazy val derivedDiffer$macro$3: difflicious.Differ[difflicious.testtypes.TreeCaseClass2] = new difflicious.differ.LazyDiffer[difflicious.testtypes.TreeCaseClass2](new difflicious.differ.ProductDiffer[difflicious.testtypes.TreeCaseClass2](fieldDiffers = scala.Vector.apply[Tuple2[String, difflicious.Differ[Any]]](Tuple2.apply[String, difflicious.Differ[Any]]("value", difflicious.Differ.stringDiffer.asInstanceOf[difflicious.Differ[Any]])), isIgnored = false, typeName = difflicious.utils.TypeName.apply[Any](long = "difflicious.testtypes.TreeCaseClass2", short = "TreeCaseClass2", typeArguments = Nil))) (derivedDiffer$macro$2: difflicious.Differ[difflicious.testtypes.TreeContainer]) }: difflicious.Differ[difflicious.testtypes.TreeContainer]) diff --git a/modules/coretest/src/test/scala/difflicious/DifferSpec.scala b/modules/coretest/src/test/scala/difflicious/DifferSpec.scala index b772b2a..6295b37 100644 --- a/modules/coretest/src/test/scala/difflicious/DifferSpec.scala +++ b/modules/coretest/src/test/scala/difflicious/DifferSpec.scala @@ -690,29 +690,29 @@ class DifferSpec extends ScalaCheckSuite with ScalaVersionDependentTests { ) } - test("Record: isOk == true if two values are equal") { + test("Product: isOk == true if two values are equal") { assertOkIfValuesEqualProp(CC.differ) } - test("Record: isOk == false if two values are not equal") { + test("Product: isOk == false if two values are not equal") { assertNotOkIfNotEqualProp(CC.differ) } - test("Record: isOk always true if differ is marked ignored") { + test("Product: isOk always true if differ is marked ignored") { assertIsOkIfIgnoredProp(CC.differ) } - test("Record: Attempting to update nonexistent field fails") { + test("Product: Attempting to update nonexistent field fails") { assertEquals( CC.differ.configureRaw(ConfigurePath.of("nonexistent"), ConfigureOp.ignore), Left( ConfigureError - .NonExistentField(ConfigurePath(Vector("nonexistent"), List.empty), "RecordDiffer"), + .NonExistentField(ConfigurePath(Vector("nonexistent"), List.empty), "ProductDiffer"), ), ) } - test("Record: Trying to update the differ with PairBy op should fail") { + test("Product: Trying to update the differ with PairBy op should fail") { assertEquals( CC.differ.configureRaw(ConfigurePath.current, ConfigureOp.PairBy.Index), Left( @@ -720,13 +720,13 @@ class DifferSpec extends ScalaCheckSuite with ScalaVersionDependentTests { .InvalidConfigureOp( ConfigurePath(Vector.empty, List.empty), ConfigureOp.PairBy.Index, - "RecordDiffer", + "ProductDiffer", ), ), ) } - test("Record: ignoreFieldByNameOrFail succeeds if field exists") { + test("Product: ignoreFieldByNameOrFail succeeds if field exists") { assertEquals( CC.differ.configureRaw(ConfigurePath.current, ConfigureOp.PairBy.Index), Left( @@ -734,7 +734,7 @@ class DifferSpec extends ScalaCheckSuite with ScalaVersionDependentTests { .InvalidConfigureOp( ConfigurePath(Vector.empty, List.empty), ConfigureOp.PairBy.Index, - "RecordDiffer", + "ProductDiffer", ), ), ) diff --git a/project/TupleDifferInstancesGen.scala b/project/TupleDifferInstancesGen.scala index c741076..a5658b4 100644 --- a/project/TupleDifferInstancesGen.scala +++ b/project/TupleDifferInstancesGen.scala @@ -14,11 +14,11 @@ object TupleDifferInstancesGen { } .mkString(",\n ")}, | typeName: TypeName[${typeName}] - |): RecordDiffer[$typeName] = new RecordDiffer[$typeName]( - | ListMap( + |): ProductDiffer[$typeName] = new ProductDiffer[$typeName]( + | Vector( | ${(1 to tupleSize) .map { t => - s""""_$t" -> Tuple2(_._$t, a${t}Diff.asInstanceOf[Differ[Any]])""" + s""""_$t" -> a${t}Diff.asInstanceOf[Differ[Any]]""" } .mkString(",\n ")} | ), @@ -35,10 +35,9 @@ object TupleDifferInstancesGen { s""" |package difflicious | - |import difflicious.differ.RecordDiffer + |import difflicious.differ.ProductDiffer |import difflicious.utils.TypeName | - |import scala.collection.immutable.ListMap |// $$COVERAGE-OFF$$ |trait DifferTupleInstances { | ${iter}