Move FunctionK macro into Scala 2-specific directory

core/src/main/scala-2.x/src/main/scala/cats/arrow/FunctionKMacros.scala

@@ -0,0 +1,102 @@
+package cats
+package arrow
+
+import scala.language.experimental.macros
+import scala.reflect.macros.blackbox.Context
+
+private[arrow] class FunctionKMacroMethods {
+
+  /**
+   * Lifts function `f` of `F[A] => G[A]` into a `FunctionK[F, G]`.
+   *
+   * {{{
+   *   def headOption[A](list: List[A]): Option[A] = list.headOption
+   *   val lifted: FunctionK[List, Option] = FunctionK.lift(headOption)
+   * }}}
+   *
+   * Note: This method has a macro implementation that returns a new
+   * `FunctionK` instance as follows:
+   *
+   * {{{
+   *   new FunctionK[F, G] {
+   *     def apply[A](fa: F[A]): G[A] = f(fa)
+   *   }
+   * }}}
+   *
+   * Additionally, the type parameters on `f` must not be specified.
+   */
+  def lift[F[_], G[_]](f: (F[α] => G[α]) forSome { type α }): FunctionK[F, G] =
+    macro FunctionKMacros.lift[F, G]
+}
+
+private[arrow] object FunctionKMacros {
+
+  def lift[F[_], G[_]](c: Context)(
+    f: c.Expr[(F[α] => G[α]) forSome { type α }]
+  )(implicit
+    evF: c.WeakTypeTag[F[_]],
+    evG: c.WeakTypeTag[G[_]]
+  ): c.Expr[FunctionK[F, G]] =
+    c.Expr[FunctionK[F, G]](new Lifter[c.type](c).lift[F, G](f.tree))
+  // ^^note: extra space after c.type to appease scalastyle
+
+  private[this] class Lifter[C <: Context](val c: C) {
+    import c.universe._
+
+    def lift[F[_], G[_]](tree: Tree)(implicit
+      evF: c.WeakTypeTag[F[_]],
+      evG: c.WeakTypeTag[G[_]]
+    ): Tree =
+      unblock(tree) match {
+        case q"($param) => $trans[..$typeArgs](${arg: Ident})" if param.name == arg.name =>
+          typeArgs
+            .collect { case tt: TypeTree => tt }
+            .find(tt => Option(tt.original).isDefined)
+            .foreach { param =>
+              c.abort(param.pos,
+                      s"type parameter $param must not be supplied when lifting function $trans to FunctionK"
+              )
+            }
+
+          val F = punchHole(evF.tpe)
+          val G = punchHole(evG.tpe)
+
+          q"""
+        new _root_.cats.arrow.FunctionK[$F, $G] {
+          def apply[A](fa: $F[A]): $G[A] = $trans(fa)
+        }
+       """
+        case other =>
+          c.abort(other.pos, s"Unexpected tree $other when lifting to FunctionK")
+      }
+
+    private[this] def unblock(tree: Tree): Tree =
+      tree match {
+        case Block(Nil, expr) => expr
+        case _                => tree
+      }
+
+    private[this] def punchHole(tpe: Type): Tree =
+      tpe match {
+        case PolyType(undet :: Nil, underlying: TypeRef) =>
+          val α = TypeName("α")
+          def rebind(typeRef: TypeRef): Tree =
+            if (typeRef.sym == undet) tq"$α"
+            else {
+              val args = typeRef.args.map {
+                case ref: TypeRef => rebind(ref)
+                case arg          => tq"$arg"
+              }
+              tq"${typeRef.sym}[..$args]"
+            }
+          val rebound = rebind(underlying)
+          tq"""({type λ[$α] = $rebound})#λ"""
+        case TypeRef(pre, sym, Nil) =>
+          tq"$sym"
+        case _ =>
+          c.abort(c.enclosingPosition, s"Unexpected type $tpe when lifting to FunctionK")
+      }
+
+  }
+
+}

core/src/main/scala-3.x/src/main/scala/cats/arrow/FunctionKMacros.scala

@@ -0,0 +1,4 @@
+package cats
+package arrow
+
+private[arrow] class FunctionKMacroMethods

core/src/main/scala/cats/arrow/FunctionK.scala

@@ -1,9 +1,6 @@
 package cats
 package arrow
 
-import scala.language.experimental.macros
-import scala.reflect.macros.blackbox.Context
-
 import cats.data.{EitherK, Tuple2K}
 
 /**
@@ -64,105 +61,11 @@ trait FunctionK[F[_], G[_]] extends Serializable { self =>
     new FunctionK[F, Tuple2K[G, H, *]] { def apply[A](fa: F[A]): Tuple2K[G, H, A] = Tuple2K(self(fa), h(fa)) }
 }
 
-object FunctionK {
+object FunctionK extends FunctionKMacroMethods {
 
   /**
    * The identity transformation of `F` to `F`
    */
   def id[F[_]]: FunctionK[F, F] = new FunctionK[F, F] { def apply[A](fa: F[A]): F[A] = fa }
 
-  /**
-   * Lifts function `f` of `F[A] => G[A]` into a `FunctionK[F, G]`.
-   *
-   * {{{
-   *   def headOption[A](list: List[A]): Option[A] = list.headOption
-   *   val lifted: FunctionK[List, Option] = FunctionK.lift(headOption)
-   * }}}
-   *
-   * Note: This method has a macro implementation that returns a new
-   * `FunctionK` instance as follows:
-   *
-   * {{{
-   *   new FunctionK[F, G] {
-   *     def apply[A](fa: F[A]): G[A] = f(fa)
-   *   }
-   * }}}
-   *
-   * Additionally, the type parameters on `f` must not be specified.
-   */
-  def lift[F[_], G[_]](f: (F[α] => G[α]) forSome { type α }): FunctionK[F, G] =
-    macro FunctionKMacros.lift[F, G]
-
-}
-
-private[arrow] object FunctionKMacros {
-
-  def lift[F[_], G[_]](c: Context)(
-    f: c.Expr[(F[α] => G[α]) forSome { type α }]
-  )(implicit
-    evF: c.WeakTypeTag[F[_]],
-    evG: c.WeakTypeTag[G[_]]
-  ): c.Expr[FunctionK[F, G]] =
-    c.Expr[FunctionK[F, G]](new Lifter[c.type](c).lift[F, G](f.tree))
-  // ^^note: extra space after c.type to appease scalastyle
-
-  private[this] class Lifter[C <: Context](val c: C) {
-    import c.universe._
-
-    def lift[F[_], G[_]](tree: Tree)(implicit
-      evF: c.WeakTypeTag[F[_]],
-      evG: c.WeakTypeTag[G[_]]
-    ): Tree =
-      unblock(tree) match {
-        case q"($param) => $trans[..$typeArgs](${arg: Ident})" if param.name == arg.name =>
-          typeArgs
-            .collect { case tt: TypeTree => tt }
-            .find(tt => Option(tt.original).isDefined)
-            .foreach { param =>
-              c.abort(param.pos,
-                      s"type parameter $param must not be supplied when lifting function $trans to FunctionK"
-              )
-            }
-
-          val F = punchHole(evF.tpe)
-          val G = punchHole(evG.tpe)
-
-          q"""
-        new _root_.cats.arrow.FunctionK[$F, $G] {
-          def apply[A](fa: $F[A]): $G[A] = $trans(fa)
-        }
-       """
-        case other =>
-          c.abort(other.pos, s"Unexpected tree $other when lifting to FunctionK")
-      }
-
-    private[this] def unblock(tree: Tree): Tree =
-      tree match {
-        case Block(Nil, expr) => expr
-        case _                => tree
-      }
-
-    private[this] def punchHole(tpe: Type): Tree =
-      tpe match {
-        case PolyType(undet :: Nil, underlying: TypeRef) =>
-          val α = TypeName("α")
-          def rebind(typeRef: TypeRef): Tree =
-            if (typeRef.sym == undet) tq"$α"
-            else {
-              val args = typeRef.args.map {
-                case ref: TypeRef => rebind(ref)
-                case arg          => tq"$arg"
-              }
-              tq"${typeRef.sym}[..$args]"
-            }
-          val rebound = rebind(underlying)
-          tq"""({type λ[$α] = $rebound})#λ"""
-        case TypeRef(pre, sym, Nil) =>
-          tq"$sym"
-        case _ =>
-          c.abort(c.enclosingPosition, s"Unexpected type $tpe when lifting to FunctionK")
-      }
-
-  }
-
 }