From 9cf166013a87b8e06ec09595c50081700e7c8a6c Mon Sep 17 00:00:00 2001 From: Jon Pretty Date: Mon, 12 Jun 2017 14:20:04 +0200 Subject: Remove spurious generic.scala~ file --- core/src/main/scala/generic.scala~ | 173 ------------------------------------- 1 file changed, 173 deletions(-) delete mode 100644 core/src/main/scala/generic.scala~ (limited to 'core/src/main/scala') 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.") - } - } - -} - -- cgit v1.2.3