Merge pull request #2821 from xeno-by/topic/fundep-materialization

SI-7470 implements fundep materialization

1 files changed, 52 insertions, 12 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
index 6b9537e27d..b3675d6a82 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
@@ -589,18 +589,23 @@ trait Macros extends FastTrack with MacroRuntimes with Traces with Helpers {
   /** Expands a term macro used in apply role as `M(2)(3)` in `val x = M(2)(3)`.
    *  @see MacroExpander
    */
-  def macroExpandApply(typer: Typer, expandee: Tree, mode: Mode, pt: Type) = {
+  def macroExpandApply(typer: Typer, expandee: Tree, mode: Mode, pt: Type): Tree = {
     object expander extends TermMacroExpander(APPLY_ROLE, typer, expandee, mode, pt) {
       override def onSuccess(expanded: Tree) = {
         // prematurely annotate the tree with a macro expansion attachment
         // so that adapt called indirectly by typer.typed knows that it needs to apply the existential fixup
         linkExpandeeAndExpanded(expandee, expanded)
-        var expectedTpe = expandee.tpe
-        if (isNullaryInvocation(expandee)) expectedTpe = expectedTpe.finalResultType
+        // approximation is necessary for whitebox macros to guide type inference
+        // read more in the comments for onDelayed below
+        def approximate(tp: Type) = {
+          val undetparams = tp collect { case tp if tp.typeSymbol.isTypeParameter => tp.typeSymbol }
+          deriveTypeWithWildcards(undetparams)(tp)
+        }
+        val macroPtApprox = approximate(if (isNullaryInvocation(expandee)) expandee.tpe.finalResultType else expandee.tpe)
         // `macroExpandApply` is called from `adapt`, where implicit conversions are disabled
         // therefore we need to re-enable the conversions back temporarily
-        if (macroDebugVerbose) println(s"typecheck #1 (against expectedTpe = $expectedTpe): $expanded")
-        val expanded1 = typer.context.withImplicitsEnabled(typer.typed(expanded, mode, expectedTpe))
+        if (macroDebugVerbose) println(s"typecheck #1 (against macroPtApprox = $macroPtApprox): $expanded")
+        val expanded1 = typer.context.withImplicitsEnabled(typer.typed(expanded, mode, macroPtApprox))
         if (expanded1.isErrorTyped) {
           if (macroDebugVerbose) println(s"typecheck #1 has failed: ${typer.context.reportBuffer.errors}")
           expanded1
@@ -612,6 +617,8 @@ trait Macros extends FastTrack with MacroRuntimes with Traces with Helpers {
         }
       }
       override def onDelayed(delayed: Tree) = {
+        // =========== THE SITUATION ===========
+        //
         // If we've been delayed (i.e. bailed out of the expansion because of undetermined type params present in the expandee),
         // then there are two possible situations we're in:
         // 1) We're in POLYmode, when the typer tests the waters wrt type inference
@@ -627,12 +634,43 @@ trait Macros extends FastTrack with MacroRuntimes with Traces with Helpers {
         // the undetermined type params. Therefore we need to do something ourselves or otherwise this
         // expandee will forever remaing not expanded (see SI-5692). A traditional way out of this conundrum
         // is to call `instantiate` and let the inferencer try to find the way out. It works for simple cases,
-        // but sometimes, if the inferencer lacks information, it will be forced to approximate. This prevents
-        // an important class of macros, fundep materializers, from working, which I perceive is a problem we need to solve.
-        // For details see SI-7470.
+        // but sometimes, if the inferencer lacks information, it will be forced to approximate.
+        //
+        // =========== THE PROBLEM ===========
+        //
+        // Consider the following example (thanks, Miles!):
+        //
+        // Iso represents an isomorphism between two datatypes:
+        // 1) An arbitrary one (e.g. a random case class)
+        // 2) A uniform representation for all datatypes (e.g. an HList)
+        //
+        //   trait Iso[T, U] {
+        //   def to(t : T) : U
+        //   def from(u : U) : T
+        //   }
+        //   implicit def materializeIso[T, U]: Iso[T, U] = macro ???
+        //
+        //   case class Foo(i: Int, s: String, b: Boolean)
+        //   def foo[C, L](c: C)(implicit iso: Iso[C, L]): L = iso.to(c)
+        //   foo(Foo(23, "foo", true))
+        //
+        // In the snippet above, even though we know that there's a fundep going from T to U
+        // (in a sense that a datatype's uniform representation is unambiguously determined by the datatype,
+        // e.g. for Foo it will be Int :: String :: Boolean :: HNil), there's no way to convey this information
+        // to the typechecker. Therefore the typechecker will infer Nothing for L, which is hardly what we want.
+        //
+        // =========== THE SOLUTION ===========
+        //
+        // To give materializers a chance to say their word before vanilla inference kicks in,
+        // we infer as much as possible (e.g. in the example above even though L is hopeless, C still can be inferred to Foo)
+        // and then trigger macro expansion with the undetermined type parameters still there.
+        // Thanks to that the materializer can take a look at what's going on and react accordingly.
         val shouldInstantiate = typer.context.undetparams.nonEmpty && !mode.inPolyMode
-        if (shouldInstantiate) typer.instantiatePossiblyExpectingUnit(delayed, mode, pt)
-        else delayed
+        if (shouldInstantiate) {
+          forced += delayed
+          typer.infer.inferExprInstance(delayed, typer.context.extractUndetparams(), pt, keepNothings = false)
+          macroExpandApply(typer, delayed, mode, pt)
+        } else delayed
       }
     }
     expander(expandee)
@@ -750,10 +788,12 @@ trait Macros extends FastTrack with MacroRuntimes with Traces with Helpers {
    *    2) undetparams (sym.isTypeParameter && !sym.isSkolem)
    */
   var hasPendingMacroExpansions = false
+  private val forced = perRunCaches.newWeakSet[Tree]
   private val delayed = perRunCaches.newWeakMap[Tree, scala.collection.mutable.Set[Int]]()
   private def isDelayed(expandee: Tree) = delayed contains expandee
   private def calculateUndetparams(expandee: Tree): scala.collection.mutable.Set[Int] =
-    delayed.get(expandee).getOrElse {
+    if (forced(expandee)) scala.collection.mutable.Set[Int]()
+    else delayed.getOrElse(expandee, {
       val calculated = scala.collection.mutable.Set[Symbol]()
       expandee foreach (sub => {
         def traverse(sym: Symbol) = if (sym != null && (undetparams contains sym.id)) calculated += sym
@@ -762,7 +802,7 @@ trait Macros extends FastTrack with MacroRuntimes with Traces with Helpers {
       })
       macroLogVerbose("calculateUndetparams: %s".format(calculated))
       calculated map (_.id)
-    }
+    })
   private val undetparams = perRunCaches.newSet[Int]()
   def notifyUndetparamsAdded(newUndets: List[Symbol]): Unit = {
     undetparams ++= newUndets map (_.id)