Merge pull request #56 from propensive/sealed-trait-typename-not-lowercased

typeName is now the full name of the type, in original case

3 files changed, 37 insertions, 6 deletions

diff --git a/core/shared/src/main/scala/magnolia.scala b/core/shared/src/main/scala/magnolia.scala
index c4c13e6..6528db0 100644
--- a/core/shared/src/main/scala/magnolia.scala
+++ b/core/shared/src/main/scala/magnolia.scala
@@ -223,10 +223,11 @@ object Magnolia {
       val isValueClass = genericType <:< typeOf[AnyVal] && !primitives.exists(_ =:= genericType)
 
       val resultType = appliedType(typeConstructor, genericType)
+        
+      val className = s"${genericType.typeSymbol.owner.fullName}.${genericType.typeSymbol.name.decodedName}"
 
       val result = if (isCaseObject) {
         val obj = companionRef(genericType)
-        val className = genericType.typeSymbol.name.decodedName.toString
 
         val impl = q"""
           ${c.prefix}.combine($magnoliaPkg.Magnolia.caseClass[$typeConstructor, $genericType](
@@ -239,7 +240,6 @@ object Magnolia {
           case m: MethodSymbol if m.isCaseAccessor || (isValueClass && m.isParamAccessor) =>
             m.asMethod
         }
-        val className = genericType.typeSymbol.name.decodedName.toString
 
         case class CaseParam(sym: c.universe.MethodSymbol,
                              repeated: Boolean,
@@ -372,13 +372,13 @@ object Magnolia {
         val assignments = typeclasses.zipWithIndex.map {
           case ((typ, typeclass), idx) =>
             q"""$subtypesVal($idx) = $magnoliaPkg.Magnolia.subtype[$typeConstructor, $genericType, $typ](
-            ${typ.typeSymbol.fullName.toString},
+            ${s"${typ.typeSymbol.owner.fullName}.${typ.typeSymbol.name.decodedName}"},
             $typeclass,
             (t: $genericType) => t.isInstanceOf[$typ],
             (t: $genericType) => t.asInstanceOf[$typ]
           )"""
         }
-
+            
         Some {
           Typeclass(
             genericType,
@@ -389,7 +389,7 @@ object Magnolia {
             ..$assignments
             
             ${c.prefix}.dispatch(new $magnoliaPkg.SealedTrait(
-              $genericTypeName,
+              $className,
               $subtypesVal: $scalaPkg.Array[$magnoliaPkg.Subtype[$typeConstructor, $genericType]])
             ): $resultType
           }"""
diff --git a/examples/shared/src/main/scala/typename.scala b/examples/shared/src/main/scala/typename.scala
new file mode 100644
index 0000000..c1e1fd2
--- /dev/null
+++ b/examples/shared/src/main/scala/typename.scala
@@ -0,0 +1,19 @@
+package magnolia.examples
+
+import language.experimental.macros
+
+import magnolia._
+
+trait TypeName[T] { def name: String }
+
+object TypeName {
+  type Typeclass[T] = TypeName[T]
+  def combine[T](ctx: CaseClass[TypeName, T]): TypeName[T] =
+    new TypeName[T] { def name: String = ctx.typeName }
+
+  def dispatch[T](ctx: SealedTrait[TypeName, T]): TypeName[T] =
+    new TypeName[T] { def name: String = ctx.typeName }
+
+  implicit def gen[T]: TypeName[T] = macro Magnolia.gen[T]
+}
+
diff --git a/tests/src/main/scala/tests.scala b/tests/src/main/scala/tests.scala
index 4c2a48e..96a2c2b 100644
--- a/tests/src/main/scala/tests.scala
+++ b/tests/src/main/scala/tests.scala
@@ -1,5 +1,7 @@
 package magnolia.tests
 
+import language.experimental.macros
+
 import magnolia._
 import estrapade._
 import contextual.data.scalac._
@@ -51,7 +53,7 @@ case class Portfolio(companies: Company*)
 
 object Tests extends TestApp {
 
-  def tests() = for (i <- 1 to 1000) {
+  def tests() = for (i <- 1 to 1) {
     import examples._
 
     test("construct a Show product instance with alternative apply functions") {
@@ -215,5 +217,15 @@ object Tests extends TestApp {
     test("show a Portfolio of Companies") {
       Show.gen[Portfolio].show(Portfolio(Company("Alice Inc"), Company("Bob & Co")))
     }.assert(_ == "Portfolio(companies=[Company(name=Alice Inc),Company(name=Bob & Co)])")
+    
+    test("sealed trait typeName should be complete and unchanged") {
+      TypeName.gen[Color].name
+    }.assert(_ == "magnolia.tests.Color")
+
+    test("case class typeName should be complete and unchanged") {
+      implicit val stringTypeName: TypeName[String] = new TypeName[String] { def name = "" }
+      TypeName.gen[Fruit].name
+    }.assert(_ == "magnolia.tests.Fruit")
+
   }
 }