import language.experimental.macros
import scala.reflect.macros.Context

trait Iso[T, U] {
  def to(t : T) : U
  // def from(u : U) : T
}

object Iso {
  implicit def materializeIso[T, U]: Iso[T, U] = macro impl[T, U]
  def impl[T: c.WeakTypeTag, U: c.WeakTypeTag](c: Context): c.Expr[Iso[T, U]] = {
    import c.universe._
    import definitions._
    import Flag._

    val sym = c.weakTypeOf[T].typeSymbol
    if (!sym.isClass || !sym.asClass.isCaseClass) c.abort(c.enclosingPosition, s"$sym is not a case class")
    val fields = sym.typeSignature.declarations.toList.collect{ case x: TermSymbol if x.isVal && x.isCaseAccessor => x }

    def mkTpt() = {
      val core = Ident(TupleClass(fields.length) orElse UnitClass)
      if (fields.length == 0) core
      else AppliedTypeTree(core, fields map (f => TypeTree(f.typeSignature)))
    }

    def mkFrom() = {
      if (fields.length == 0) Literal(Constant(Unit))
      else Apply(Ident(newTermName("Tuple" + fields.length)), fields map (f => Select(Ident(newTermName("f")), newTermName(f.name.toString.trim))))
    }

    val evidenceClass = ClassDef(Modifiers(FINAL), newTypeName("$anon"), List(), Template(
      List(AppliedTypeTree(Ident(newTypeName("Iso")), List(Ident(sym), mkTpt()))),
      emptyValDef,
      List(
        DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(Apply(Select(Super(This(tpnme.EMPTY), tpnme.EMPTY), nme.CONSTRUCTOR), List())), Literal(Constant(())))),
        DefDef(Modifiers(), newTermName("to"), List(), List(List(ValDef(Modifiers(PARAM), newTermName("f"), Ident(sym), EmptyTree))), TypeTree(), mkFrom()))))
    c.Expr[Iso[T, U]](Block(List(evidenceClass), Apply(Select(New(Ident(newTypeName("$anon"))), nme.CONSTRUCTOR), List())))
  }
}

object Test extends App {
  case class Foo(i: Int, s: String, b: Boolean)
  def foo[C, L](c: C)(implicit iso: Iso[C, L]): L = iso.to(c)

  {
    val equiv = foo(Foo(23, "foo", true))
    def typed[T](t: => T) {}
    typed[(Int, String, Boolean)](equiv)
    println(equiv)
  }
}

21:21 ~/Projects/Kepler_5923/sandbox (ticket/5923)$ ssli
Test.scala:6: Iso.materializeIso is not a valid implicit value for Iso[Test.Foo,L] because:
hasMatchingSymbol reported error: type mismatch;
 found   : Iso[Test.Foo,(Int, String, Boolean)]
 required: Iso[Test.Foo,Nothing]
Note: (Int, String, Boolean) >: Nothing, but trait Iso is invariant in type U.
You may wish to define U as -U instead. (SLS 4.5)
    val equiv = foo(Foo(23, "foo", true))
                   ^
Test.scala:6: error: could not find implicit value for parameter iso: Iso[Test.Foo,L]
    val equiv = foo(Foo(23, "foo", true))
                   ^
one error found