Quick sketch of a not very general implementation of boilerplate-free coyoneda'd constructors

FreeMacros.scala

import scala.language.experimental.macros
import scala.reflect.macros.whitebox

class FreeMacros(val c: whitebox.Context) {
  import c.universe._

  def smartName(name: String): String = (
    name.toList match {
      case h :: t => h.toLower :: t
      case Nil => Nil
    }
  ).mkString

  def liftedImpl[F[_]](implicit t: c.WeakTypeTag[F[_]]): Tree = {
    val atc = t.tpe.typeConstructor

    val constructors = t.tpe.typeSymbol.asClass.knownDirectSubclasses.map {
      case constructor: ClassSymbol =>
        val companion = constructor.companion
        val ctpe = constructor.typeSignature
        val ctc = ctpe.typeConstructor

        val methodName = TermName(smartName(constructor.name.toString))
        val A = TypeName(c.freshName())

        val (params, names) = ctpe.decls.collect {
          case m: MethodSymbol if m.isCaseAccessor =>
            m.typeSignatureIn(atc) match {
              case NullaryMethodType(returnType) =>
                val param =
                  if (returnType.typeSymbol == ctc.typeParams.head)
                    q"val ${m.name}: $A"
                  else
                    q"val ${m.name}: $returnType"

                (param, m.name)
                
          }
        }.unzip

        q"""
          def $methodName[$A](..$params): _root_.cats.free.FreeC[$atc, $A] =
            _root_.cats.free.Free.liftFC[$atc, $A](
              $companion.apply[$A](..$names)
            )
        """
    }

    q"new { ..$constructors }"
  }
}

object FreeMacros {
  def liftConstructors[F[_]]: Any = macro FreeMacros.liftedImpl[F]
}

Yeah, the next step is lining up the type parameter on each constructor with the appropriate one on the ADT type (if needed). This will fix your case, as well as the case where the constructors have other type parameters.

I'll take a stab at that this evening. It should look roughly the same for the macro annotation version.