From ed7010d896a5eb0ff3c182b67ce7cf6c0fad7b44 Mon Sep 17 00:00:00 2001 From: Piotr Krzemiński Date: Thu, 22 Jun 2017 09:18:00 +0100 Subject: refactor --- core/src/main/scala/magnolia.scala | 33 +++++++++++++++++++-------------- 1 file changed, 19 insertions(+), 14 deletions(-) diff --git a/core/src/main/scala/magnolia.scala b/core/src/main/scala/magnolia.scala index 61a00d6..27172d3 100644 --- a/core/src/main/scala/magnolia.scala +++ b/core/src/main/scala/magnolia.scala @@ -191,6 +191,8 @@ class Macros(val c: whitebox.Context) { construct.map { const => derivationImplicit match { + case CovariantDerivationImplicit(_) => + ??? case ContravariantDerivation1Implicit(impl) => q"""{ def $assignedName: $resultType = $impl.construct { sourceParameter => $const } @@ -206,6 +208,7 @@ class Macros(val c: whitebox.Context) { } def magnolia[T: WeakTypeTag, Typeclass: WeakTypeTag]: Tree = { + import scala.util.{Try, Success, Failure} val genericType: Type = weakTypeOf[T] val currentStack: Stack = recursionStack.get(c.enclosingPosition).getOrElse(Stack(List(), List())) @@ -220,20 +223,22 @@ class Macros(val c: whitebox.Context) { val contraDerivationType = appliedType(contraDerivationTypeclass, List(typeConstructor)) val contraDerivation2Type = appliedType(contraDerivation2Typeclass, List(typeConstructor)) - - val derivationImplicitTry = scala.util.Try[DerivationImplicit](CovariantDerivationImplicit(c.untypecheck(c.inferImplicitValue(coDerivationType, false, false)))) - .orElse(scala.util.Try(ContravariantDerivation1Implicit(c.untypecheck(c.inferImplicitValue(contraDerivationType, false, false))))) - .orElse(scala.util.Try(ContravariantDerivation2Implicit(c.untypecheck(c.inferImplicitValue(contraDerivation2Type, false, false))))) - - val derivationImplicit: DerivationImplicit = if(derivationImplicitTry.isFailure) { - c.info(c.enclosingPosition, s"could not find an implicit instance of "+ - s"CovariantDerivation[$typeConstructor] or "+ - s"ContravariantDerivation[$typeConstructor] or "+ - s"ContravariantDerivation2[$typeConstructor]", true) - throw derivationImplicitTry.failed.get - } else { - derivationImplicitTry.get - } + def findDerivationImplicit[T <: DerivationImplicit](tpe: c.Type, cons: Tree => T): Try[DerivationImplicit] = + Try(cons(c.untypecheck(c.inferImplicitValue(tpe, false, false)))) + + val derivationImplicit = + findDerivationImplicit(coDerivationType, CovariantDerivationImplicit) + .orElse(findDerivationImplicit(contraDerivationType, ContravariantDerivation1Implicit)) + .orElse(findDerivationImplicit(contraDerivation2Type, ContravariantDerivation2Implicit)) match { + case Failure(e) => + c.info(c.enclosingPosition, s"could not find an implicit instance of "+ + s"CovariantDerivation[$typeConstructor] or "+ + s"ContravariantDerivation[$typeConstructor] or "+ + s"ContravariantDerivation2[$typeConstructor]", true) + throw e + case Success(di) => + di + } if(directlyReentrant) throw DirectlyReentrantException() -- cgit v1.2.3