Remove spurious generic.scala~ file

1 files changed, 0 insertions, 173 deletions

diff --git a/core/src/main/scala/generic.scala~ b/core/src/main/scala/generic.scala~
deleted file mode 100644
index 4767435..0000000
--- a/core/src/main/scala/generic.scala~
+++ /dev/null
@@ -1,173 +0,0 @@
-package magnolia
-
-import scala.reflect._, macros._
-import macrocompat.bundle
-import scala.util.Try
-
-import scala.collection.immutable.ListMap
-
-object GlobalMutableState {
-  private[magnolia] var state: ListMap[AnyRef, AnyRef] = ListMap()
-  
-  private[magnolia] def push(key: AnyRef, value: AnyRef): Unit = {
-    state += ((key, value))
-  }
-  
-  private[magnolia] def pop(): Unit = {
-    state = state.init
-  }
-  
-  private[magnolia] def has(c: whitebox.Context)(key: AnyRef): Option[c.universe.Tree] =
-    state.get(key).asInstanceOf[Option[c.universe.Tree]]
-
-  private[magnolia] var searchType: AnyRef = null
-}
-
-@bundle
-class Macros(val context: whitebox.Context) extends GenericMacro(context) {
-  
-  
-  protected def classBody(context: whitebox.Context)(genericType: context.Type, implementation: context.Tree): context.Tree = {
-    import context.universe._
-    q"""def extract(src: _root_.magnolia.Thing): $genericType = $implementation"""
-  }
-
-  protected def dereferenceValue(context: whitebox.Context)(value: context.Tree, elem: String): context.Tree = {
-    import context.universe._
-    q"$value.access($elem)"
-  }
-  
-  protected def callDelegateMethod(context: whitebox.Context)(value: context.Tree, argument: context.Tree): context.Tree = {
-    import context.universe._
-    q"$value.extract($argument)"
-  }
-  
-  protected def coproductReduction(context: whitebox.Context)(left: context.Tree, right: context.Tree): context.Tree = {
-    import context.universe._
-    q"$left.orElse($right)"
-  }
-}
-
-abstract class GenericMacro(whiteboxContext: whitebox.Context) {
-
-  val c = whiteboxContext
-
-  def getImplicit(genericType: c.universe.Type,
-                  typeConstructor: c.universe.Type,
-                  myName: c.universe.TermName,
-                  count: Int): c.Tree = {
-    
-    import c.universe._
-    println(s"getImplicit($genericType, $count)")
-    val result = GlobalMutableState.has(c)(genericType).map { nm => q"$nm" }.orElse {
-      val searchType = appliedType(typeConstructor, genericType)
-      if(GlobalMutableState.has(c)(genericType).isEmpty) {
-        scala.util.Try {
-          GlobalMutableState.searchType = genericType
-          c.inferImplicitValue(searchType, false, false)
-        }.toOption.orElse {
-          println("Recursing")
-          directInferImplicit(genericType, typeConstructor, count + 1)
-        }
-      } else {
-        directInferImplicit(genericType, typeConstructor, count + 1)
-      }
-    }.getOrElse {
-      println("Failed 2.")
-      c.abort(c.enclosingPosition, "Could not find extractor for type "+genericType)
-    }
-
-
-    result
-  }
-  
-  def directInferImplicit(genericType: c.universe.Type,
-         typeConstructor: c.universe.Type,
-         count: Int): Option[c.Tree] = {
-    import c.universe._
-   
-    println(s"directInferImplicit($genericType, $count)")
-
-    val myName: TermName = TermName(c.freshName(genericType.typeSymbol.name.encodedName.toString.toLowerCase+"Extractor"))
-    val typeSymbol = genericType.typeSymbol
-    val classType = if(typeSymbol.isClass) Some(typeSymbol.asClass) else None
-    val isCaseClass = classType.map(_.isCaseClass).getOrElse(false)
-    val isSealedTrait = classType.map(_.isSealed).getOrElse(false)
-    val isAnyVal = genericType <:< typeOf[AnyVal]
-    
-    val resultType = appliedType(typeConstructor, genericType)
-
-    val construct = if(isCaseClass) {
-      val implicits = genericType.decls.collect {
-        case m: MethodSymbol if m.isCaseAccessor => m.asMethod
-      }.map { param =>
-        val returnType = param.returnType
-        GlobalMutableState.push(genericType, myName)
-        val imp = getImplicit(returnType, typeConstructor, myName, count)
-        GlobalMutableState.pop()
-        val dereferenced = dereferenceValue(c)(q"src", param.name.toString)
-        callDelegateMethod(c)(imp, dereferenced)
-      }
-
-      Some(q"new $genericType(..$implicits)")
-    } else if(isSealedTrait) {
-      val subtypes = classType.get.knownDirectSubclasses.to[List]
-      Some(subtypes.map(_.asType.toType).map { searchType =>
-        GlobalMutableState.push(genericType, myName)
-        val res = getImplicit(searchType, typeConstructor, myName, count)
-        GlobalMutableState.pop()
-        res
-      }.reduce(coproductReduction(c))).map { imp =>
-        callDelegateMethod(c)(imp, q"src")
-      }
-      
-    } else None
-
-    val result = construct.map { const =>
-      
-      val methodImplementation = classBody(c)(genericType, const)
-      q"""{
-        def $myName: $resultType = new $resultType {
-          $methodImplementation
-        }
-        $myName
-      }"""
-    }
-
-
-    result
-  }
-  
-  protected def classBody(c: whitebox.Context)(genericType: c.Type, implementation: c.Tree): c.Tree
-  protected def coproductReduction(c: whitebox.Context)(left: c.Tree, right: c.Tree): c.Tree
-  protected def dereferenceValue(c: whitebox.Context)(value: c.Tree, elem: String): c.Tree
-  protected def callDelegateMethod(c: whitebox.Context)(value: c.Tree, argument: c.Tree): c.Tree
-
-  def generic[T: c.WeakTypeTag, Tc: c.WeakTypeTag]: c.Tree = {
-    import c.universe._
-
-    val genericType: Type = weakTypeOf[T]
-    val reentrant = genericType == GlobalMutableState.searchType
-    if(reentrant) {
-      println("Reentrant.")
-      ???
-    }
-    val typeConstructor: Type = weakTypeOf[Tc].typeConstructor
-
-    val result = directInferImplicit(genericType, typeConstructor, 0)
-
-    println(result)
-    try result.map { tree => c.typecheck(tree) } catch {
-      case e: Exception =>
-        println(result)
-        println("Failed to typecheck because: "+e)
-    }
-
-    result.getOrElse {
-      println("Count not infer extractor...")
-      c.abort(c.enclosingPosition, "Could not infer extractor. Sorry.")
-    }
-  }
-
-}
-