Refactor Types and Exprs modules

chimney/src/main/scala-2/io/scalaland/chimney/internal/compiletime/ChimneyExprsPlatform.scala

@@ -0,0 +1,81 @@
+package io.scalaland.chimney.internal.compiletime
+
+import io.scalaland.chimney.partial
+
+private[compiletime] trait ChimneyExprsPlatform extends ChimneyExprs { this: DefinitionsPlatform =>
+
+  import c.universe.{internal as _, Transformer as _, *}
+
+  object ChimneyExpr extends ChimneyExprModule {
+
+    object PartialResult extends PartialResultModule {
+      def Value[T: Type](value: Expr[T]): Expr[partial.Result.Value[T]] =
+        c.Expr(q"_root_.io.scalaland.chimney.partial.Result.Value[${Type[T]}]($value)")
+
+      object Errors extends ErrorsModule {
+        def merge(
+            errors1: Expr[partial.Result.Errors],
+            errors2: Expr[partial.Result.Errors]
+        ): Expr[partial.Result.Errors] =
+          c.Expr(q"_root_.io.scalaland.chimney.partial.Result.Errors.merge($errors1, $errors2)")
+
+        def mergeResultNullable[T: Type](
+            errorsNullable: Expr[partial.Result.Errors],
+            result: Expr[partial.Result[T]]
+        ): Expr[partial.Result.Errors] =
+          c.Expr(
+            q"_root_.io.scalaland.chimney.partial.Result.Errors.__mergeResultNullable[${Type[T]}]($errorsNullable, $result)"
+          )
+      }
+
+      def fromEmpty[T: Type]: Expr[partial.Result[T]] =
+        c.Expr(q"_root_.io.scalaland.chimney.partial.Result.fromEmpty[${Type[T]}]")
+
+      def fromFunction[S: Type, T: Type](f: Expr[S => T]): Expr[S => partial.Result[T]] =
+        c.Expr(q"_root_.io.scalaland.chimney.partial.Result.fromFunction[${Type[S]}, ${Type[T]}]($f)")
+
+      def traverse[M: Type, A: Type, B: Type](
+          it: Expr[Iterator[A]],
+          f: Expr[A => partial.Result[B]],
+          failFast: Expr[Boolean]
+      ): Expr[partial.Result[M]] =
+        c.Expr(
+          q"_root_.io.scalaland.chimney.partial.Result.traverse[${Type[M]}, ${Type[A]}, ${Type[B]}]($it, $f, $failFast)"
+        )
+
+      def sequence[M: Type, A: Type](
+          it: Expr[Iterator[partial.Result[A]]],
+          failFast: Expr[Boolean]
+      ): Expr[partial.Result[M]] =
+        c.Expr(q"_root_.io.scalaland.chimney.partial.Result.sequence[${Type[M]}, ${Type[A]}]($it, $failFast)")
+
+      def map2[A: Type, B: Type, C: Type](
+          fa: Expr[partial.Result[A]],
+          fb: Expr[partial.Result[B]],
+          f: Expr[(A, B) => C],
+          failFast: Expr[Boolean]
+      ): Expr[partial.Result[C]] =
+        c.Expr(
+          q"_root_.io.scalaland.chimney.partial.Result.map2[${Type[A]}, ${Type[B]}, ${Type[C]}]($fa, $fb, $f, $failFast)"
+        )
+
+      def product[A: Type, B: Type](
+          fa: Expr[partial.Result[A]],
+          fb: Expr[partial.Result[B]],
+          failFast: Expr[Boolean]
+      ): Expr[partial.Result[(A, B)]] =
+        c.Expr(q"_root_.io.scalaland.chimney.partial.Result.product[${Type[A]}, ${Type[B]}]($fa, $fb, $failFast)")
+    }
+
+    object PathElement extends PathElementModule {
+      def Accessor(targetName: Expr[String]): Expr[partial.PathElement.Accessor] =
+        c.Expr(q"_root_.io.scalaland.chimney.partial.PathElement.Accessor($targetName)")
+      def Index(index: Expr[Int]): Expr[partial.PathElement.Index] =
+        c.Expr(q"_root_.io.scalaland.chimney.partial.PathElement.Index($index)")
+      def MapKey(key: Expr[Any]): Expr[partial.PathElement.MapKey] =
+        c.Expr(q"_root_.io.scalaland.chimney.partial.PathElement.MapKey($key)")
+      def MapValue(key: Expr[Any]): Expr[partial.PathElement.MapValue] =
+        c.Expr(q"_root_.io.scalaland.chimney.partial.PathElement.MapValue($key)")
+    }
+  }
+}

chimney/src/main/scala-2/io/scalaland/chimney/internal/compiletime/ChimneyTypesPlatform.scala

@@ -0,0 +1,68 @@
+package io.scalaland.chimney.internal.compiletime
+
+import io.scalaland.chimney.dsl.ImplicitTransformerPreference
+import io.scalaland.chimney.partial
+import io.scalaland.chimney.internal
+import io.scalaland.chimney.{PartialTransformer, Patcher, Transformer}
+
+private[compiletime] trait ChimneyTypesPlatform extends ChimneyTypes { this: DefinitionsPlatform =>
+
+  import c.universe.{internal as _, Transformer as _}
+
+  object ChimneyType extends ChimneyTypeModule {
+    import typeUtils.*
+
+    def Transformer[From: Type, To: Type]: Type[Transformer[From, To]] =
+      fromWeakTC[Transformer[?, ?], Transformer[From, To]](Type[From], Type[To])
+
+    def PartialTransformer[From: Type, To: Type]: Type[PartialTransformer[From, To]] =
+      fromWeakTC[PartialTransformer[?, ?], PartialTransformer[From, To]](Type[From], Type[To])
+
+    def Patcher[T: Type, Patch: Type]: Type[Patcher[T, Patch]] =
+      fromWeakTC[Patcher[?, ?], Patcher[T, Patch]](Type[T], Type[Patch])
+
+    object PartialResult extends PartialResultModule {
+      def apply[T: Type]: Type[partial.Result[T]] =
+        fromWeakTC[partial.Result[?], partial.Result[T]](Type[T])
+      def Value[T: Type]: Type[partial.Result.Value[T]] =
+        fromWeakTC[partial.Result.Value[?], partial.Result.Value[T]](Type[T])
+      val Errors: Type[partial.Result.Errors] =
+        fromWeak[partial.Result.Errors]
+    }
+
+    val PreferTotalTransformer: Type[io.scalaland.chimney.dsl.PreferTotalTransformer.type] =
+      fromWeak[io.scalaland.chimney.dsl.PreferTotalTransformer.type]
+    val PreferPartialTransformer: Type[io.scalaland.chimney.dsl.PreferPartialTransformer.type] =
+      fromWeak[io.scalaland.chimney.dsl.PreferPartialTransformer.type]
+
+    object TransformerFlags extends TransformerFlagsModule {
+      import internal.TransformerFlags.Flag
+
+      override val Default: Type[internal.TransformerFlags.Default] =
+        fromWeak[internal.TransformerFlags.Default]
+
+      def Enable[F <: Flag: Type, Flags <: internal.TransformerFlags: Type]
+          : Type[internal.TransformerFlags.Enable[F, Flags]] =
+        fromWeak[internal.TransformerFlags.Enable[F, Flags]]
+
+      def Disable[F <: Flag: Type, Flags <: internal.TransformerFlags: Type]
+          : Type[internal.TransformerFlags.Disable[F, Flags]] =
+        fromWeak[internal.TransformerFlags.Disable[F, Flags]]
+
+      object Flags extends FlagsModule {
+        val DefaultValues: Type[internal.TransformerFlags.DefaultValues] =
+          fromWeak[internal.TransformerFlags.DefaultValues]
+        val BeanGetters: Type[internal.TransformerFlags.BeanGetters] = fromWeak[internal.TransformerFlags.BeanGetters]
+        val BeanSetters: Type[internal.TransformerFlags.BeanSetters] = fromWeak[internal.TransformerFlags.BeanSetters]
+        val MethodAccessors: Type[internal.TransformerFlags.MethodAccessors] =
+          fromWeak[internal.TransformerFlags.MethodAccessors]
+        val OptionDefaultsToNone: Type[internal.TransformerFlags.OptionDefaultsToNone] =
+          fromWeak[internal.TransformerFlags.OptionDefaultsToNone]
+
+        def ImplicitConflictResolution[R <: ImplicitTransformerPreference: Type]
+            : Type[internal.TransformerFlags.ImplicitConflictResolution[R]] =
+          fromWeak[internal.TransformerFlags.ImplicitConflictResolution[R]]
+      }
+    }
+  }
+}

chimney/src/main/scala-2/io/scalaland/chimney/internal/compiletime/ConfigurationsPlatform.scala

@@ -9,8 +9,7 @@ private[compiletime] trait ConfigurationsPlatform extends Configurations { this:
 
   protected object configurationsImpl extends ConfigurationDefinitionsImpl {
 
-    // convert WeakTypeTag[T] to Type[T] automatically
-    implicit private def fromWeak[T: WeakTypeTag]: Type[T] = typeImpl.fromWeak[T]
+    import typeUtils.fromWeakConversion.*
 
     def extractRuntimeConfiguration[From: Type, ToField: Type](
         runtimeConfiguration: FieldOverride.RuntimeConfiguration,
@@ -50,20 +49,20 @@ private[compiletime] trait ConfigurationsPlatform extends Configurations { this:
     ): TransformerFlags = {
       val flags = Type[Flag].dealias
 
-      if (flags =:= Type.TransformerFlags.Default) {
+      if (flags =:= ChimneyType.TransformerFlags.Default) {
         defaultFlags
       } else if (flags.typeConstructor =:= enableTC) {
         val List(h, t) = flags.typeArgs
-        implicit val Flag: Type[FlagHead] = typeImpl.fromUntyped(h)
-        implicit val Tail: Type[FlagTail] = typeImpl.fromUntyped(t)
+        implicit val Flag: Type[FlagHead] = typeUtils.fromUntyped(h)
+        implicit val Tail: Type[FlagTail] = typeUtils.fromUntyped(t)
 
         if (Flag.typeConstructor =:= implicitConflictResolutionTC) {
           val preference = Flag.typeArgs.head
-          if (preference =:= Type.PreferTotalTransformer) {
+          if (preference =:= ChimneyType.PreferTotalTransformer) {
             extractTransformerFlags[FlagTail](defaultFlags).setImplicitConflictResolution(
               Some(dsls.PreferTotalTransformer)
             )
-          } else if (preference =:= Type.PreferPartialTransformer) {
+          } else if (preference =:= ChimneyType.PreferPartialTransformer) {
             extractTransformerFlags[FlagTail](defaultFlags).setImplicitConflictResolution(
               Some(dsls.PreferPartialTransformer)
             )
@@ -77,8 +76,8 @@ private[compiletime] trait ConfigurationsPlatform extends Configurations { this:
         }
       } else if (flags.typeConstructor =:= disableTC) {
         val List(h, t) = flags.typeArgs
-        implicit val Flag: Type[FlagHead] = typeImpl.fromUntyped(h)
-        implicit val Tail: Type[FlagTail] = typeImpl.fromUntyped(t)
+        implicit val Flag: Type[FlagHead] = typeUtils.fromUntyped(h)
+        implicit val Tail: Type[FlagTail] = typeUtils.fromUntyped(t)
 
         if (flags.typeConstructor =:= implicitConflictResolutionTC) {
           extractTransformerFlags[FlagTail](defaultFlags).setImplicitConflictResolution(None)

chimney/src/main/scala-2/io/scalaland/chimney/internal/compiletime/DefinitionsPlatform.scala

@@ -5,13 +5,11 @@ import scala.reflect.macros.blackbox
 private[compiletime] trait DefinitionsPlatform
     extends Definitions
     with TypesPlatform
+    with ChimneyTypesPlatform
     with ExprsPlatform
+    with ChimneyExprsPlatform
     with ConfigurationsPlatform
     with ResultsPlatform {
 
   val c: blackbox.Context
 }
-private[compiletime] object DefinitionsPlatform {
-  type Arbitrary
-  type Arbitrary2
-}

chimney/src/main/scala-2/io/scalaland/chimney/internal/compiletime/ExprsPlatform.scala

@@ -1,89 +1,28 @@
 package io.scalaland.chimney.internal.compiletime
 
-import io.scalaland.chimney.partial
-
 private[compiletime] trait ExprsPlatform extends Exprs { this: DefinitionsPlatform =>
 
   import c.universe.{internal as _, Transformer as _, *}
 
   final override type Expr[A] = c.Expr[A]
-  protected object exprImpl extends ExprDefinitionsImpl {
-
-    override def Unit: Expr[Unit] = c.Expr(q"()")
-
-    override def Array[A: Type](args: Expr[A]*): Expr[Array[A]] = c.Expr(q"_root_.scala.Array[${Type[A]}](..${args})")
-
-    override def Option[A: Type](value: Expr[A]): Expr[Option[A]] =
-      c.Expr(q"_root_.scala.Option[${Type[A]}]($value)")
-    override def OptionEmpty[A: Type]: Expr[Option[A]] =
-      c.Expr(q"_root_.scala.Option.empty[${Type[A]}]")
-    override def OptionApply[A: Type]: Expr[A => Option[A]] =
-      c.Expr(q"_root_.scala.Option.apply[${Type[A]}](_)")
-    override def None: Expr[scala.None.type] = c.Expr(q"_root_.scala.None")
-
-    override def Left[L: Type, R: Type](value: Expr[L]): Expr[Left[L, R]] =
-      c.Expr(q"new _root_.scala.util.Left[${Type[L]}, ${Type[R]}]($value)")
-    override def Right[L: Type, R: Type](value: Expr[R]): Expr[Right[L, R]] =
-      c.Expr(q"new _root_.scala.util.Right[${Type[L]}, ${Type[R]}]($value)")
-
-    override def PartialResultValue[T: Type](value: Expr[T]): Expr[partial.Result.Value[T]] =
-      c.Expr(q"_root_.io.scalaland.chimney.partial.Result.Value[${Type[T]}]($value)")
-
-    override def PartialResultErrorsMerge(
-        errors1: Expr[partial.Result.Errors],
-        errors2: Expr[partial.Result.Errors]
-    ): Expr[partial.Result.Errors] =
-      c.Expr(q"_root_.io.scalaland.chimney.partial.Result.Errors.merge($errors1, $errors2)")
-
-    override def PartialResultErrorsMergeResultNullable[T: Type](
-        errorsNullable: Expr[partial.Result.Errors],
-        result: Expr[partial.Result[T]]
-    ): Expr[partial.Result.Errors] =
-      c.Expr(
-        q"_root_.io.scalaland.chimney.partial.Result.Errors.__mergeResultNullable[${Type[T]}]($errorsNullable, $result)"
-      )
-    override def PartialResultEmpty[T: Type]: Expr[partial.Result[T]] =
-      c.Expr(q"_root_.io.scalaland.chimney.partial.Result.fromEmpty[${Type[T]}]")
-    override def PartialResultFunction[S: Type, T: Type](f: Expr[S => T]): Expr[S => partial.Result[T]] =
-      c.Expr(q"_root_.io.scalaland.chimney.partial.Result.fromFunction[${Type[S]}, ${Type[T]}]($f)")
-    override def PartialResultTraverse[M: Type, A: Type, B: Type](
-        it: Expr[Iterator[A]],
-        f: Expr[A => partial.Result[B]],
-        failFast: Expr[Boolean]
-    ): Expr[partial.Result[M]] =
-      c.Expr(
-        q"_root_.io.scalaland.chimney.partial.Result.traverse[${Type[M]}, ${Type[A]}, ${Type[B]}]($it, $f, $failFast)"
-      )
-    override def PartialResultSequence[M: Type, A: Type](
-        it: Expr[Iterator[partial.Result[A]]],
-        failFast: Expr[Boolean]
-    ): Expr[partial.Result[M]] =
-      c.Expr(q"_root_.io.scalaland.chimney.partial.Result.sequence[${Type[M]}, ${Type[A]}]($it, $failFast)")
-    override def PartialResultMap2[A: Type, B: Type, C: Type](
-        fa: Expr[partial.Result[A]],
-        fb: Expr[partial.Result[B]],
-        f: Expr[(A, B) => C],
-        failFast: Expr[Boolean]
-    ): Expr[partial.Result[C]] =
-      c.Expr(
-        q"_root_.io.scalaland.chimney.partial.Result.map2[${Type[A]}, ${Type[B]}, ${Type[C]}]($fa, $fb, $f, $failFast)"
-      )
-    override def PartialResultProduct[A: Type, B: Type](
-        fa: Expr[partial.Result[A]],
-        fb: Expr[partial.Result[B]],
-        failFast: Expr[Boolean]
-    ): Expr[partial.Result[(A, B)]] =
-      c.Expr(q"_root_.io.scalaland.chimney.partial.Result.product[${Type[A]}, ${Type[B]}]($fa, $fb, $failFast)")
-
-    override def PathElementAccessor(targetName: Expr[String]): Expr[partial.PathElement.Accessor] =
-      c.Expr(q"_root_.io.scalaland.chimney.partial.PathElement.Accessor($targetName)")
-    override def PathElementIndex(index: Expr[Int]): Expr[partial.PathElement.Index] =
-      c.Expr(q"_root_.io.scalaland.chimney.partial.PathElement.Index($index)")
-    override def PathElementMapKey(key: Expr[Any]): Expr[partial.PathElement.MapKey] =
-      c.Expr(q"_root_.io.scalaland.chimney.partial.PathElement.MapKey($key)")
-    override def PathElementMapValue(key: Expr[Any]): Expr[partial.PathElement.MapValue] =
-      c.Expr(q"_root_.io.scalaland.chimney.partial.PathElement.MapValue($key)")
 
-    override def AsInstanceOf[T: Type, S: Type](expr: Expr[T]): Expr[S] = c.Expr(q"${expr}.asInstanceOf[${Type[S]}]")
+  object Expr extends ExprModule {
+    val Unit: Expr[Unit] = c.Expr(q"()")
+    def Array[A: Type](args: Expr[A]*): Expr[Array[A]] = c.Expr(q"_root_.scala.Array[${Type[A]}](..${args})")
+    object Option extends OptionModule {
+      def apply[A: Type](a: Expr[A]): Expr[Option[A]] = c.Expr(q"_root_.scala.Option[${Type[A]}]($a)")
+      def empty[A: Type]: Expr[Option[A]] = c.Expr(q"_root_.scala.Option.empty[${Type[A]}]")
+      def apply[A: Type]: Expr[A => Option[A]] = c.Expr(q"_root_.scala.Option.apply[${Type[A]}](_)")
+      val None: Expr[scala.None.type] = c.Expr(q"_root_.scala.None")
+    }
+
+    object Either extends EitherModule {
+      def Left[L: Type, R: Type](value: Expr[L]): Expr[Left[L, R]] =
+        c.Expr(q"new _root_.scala.util.Left[${Type[L]}, ${Type[R]}]($value)")
+      def Right[L: Type, R: Type](value: Expr[R]): Expr[Right[L, R]] =
+        c.Expr(q"new _root_.scala.util.Right[${Type[L]}, ${Type[R]}]($value)")
+    }
+
+    def asInstanceOf[T: Type, U: Type](expr: Expr[T]): Expr[U] = c.Expr(q"${expr}.asInstanceOf[${Type[U]}]")
   }
 }