Only capture contextual implicits

Author: odersky

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -1103,19 +1103,24 @@ trait Implicits { self: Typer =>
       val eligible =
         if (contextual) ctx.implicits.eligible(wildProto)
         else implicitScope(wildProto).eligible
-      searchImplicits(eligible, contextual).recoverWith {
-        failure => failure.reason match {
-          case _: AmbiguousImplicits => failure
-          case reason =>
-            if (contextual)
-              bestImplicit(contextual = false).recoverWith {
-                failure2 => reason match {
-                  case (_: DivergingImplicit) | (_: ShadowedImplicit) => failure
-                  case _ => failure2
+      searchImplicits(eligible, contextual) match {
+        case result: SearchSuccess =>
+          if (contextual && ctx.mode.is(Mode.BodyOfInlined))
+            Inliner.markContextualImplicit(result.tree)
+          result
+        case failure: SearchFailure =>
+          failure.reason match {
+            case _: AmbiguousImplicits => failure
+            case reason =>
+              if (contextual)
+                bestImplicit(contextual = false).recoverWith {
+                  failure2 => reason match {
+                    case (_: DivergingImplicit) | (_: ShadowedImplicit) => failure
+                    case _ => failure2
+                  }
                 }
-              }
-            else failure
-        }
+              else failure
+          }
       }
     }
 

compiler/src/dotty/tools/dotc/typer/Inliner.scala

@@ -32,6 +32,15 @@ import util.Property
 object Inliner {
   import tpd._
 
+  /** Marks an implicit reference found in the context (as opposed to the implicit scope)
+   *  from an inlineable body. Such references will be carried along with the body to
+   *  the expansion site.
+   */
+  private val ContextualImplicit = new Property.StickyKey[Unit]
+
+  def markContextualImplicit(tree: Tree)(implicit ctx: Context): Unit =
+    methPart(tree).putAttachment(ContextualImplicit, ())
+
   class InlineAccessors extends AccessProxies {
 
     /** A tree map which inserts accessors for all non-public term members accessed
@@ -144,10 +153,11 @@ object Inliner {
       val nameAtPos = mutable.Map[Position, Name]()
       val implicitSyms = mutable.Set[Symbol]()
       val implicitRefs = new mutable.ListBuffer[Tree]
-      def registerIfImplicit(tree: Tree) = tree match {
+      def registerIfContextualImplicit(tree: Tree) = tree match {
         case tree: RefTree
-        if tree.pos.start == tree.pos.end && tree.symbol.is(Implicit) &&
-           isExternal(tree.symbol) && !implicitSyms.contains(tree.symbol) =>
+        if tree.removeAttachment(ContextualImplicit).isDefined &&
+           isExternal(tree.symbol) &&
+           !implicitSyms.contains(tree.symbol) =>
           if (tree.existsSubTree(t => isLocal(tree.symbol, inlineMethod)))
             ctx.warning("implicit reference $tree is dropped at inline site because it refers to local symbol(s)", tree.pos)
           else {
@@ -169,7 +179,7 @@ object Inliner {
             nameAtPos(tree.pos.toSynthetic) = tree.symbol.name
           case _ =>
         }
-        registerIfImplicit(tree)
+        registerIfContextualImplicit(tree)
         traverseChildren(tree)
       }
     }
@@ -521,21 +531,18 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
 
     trace(i"inlining $call\n, BINDINGS =\n${bindingsBuf.toList}%\n%\nEXPANSION =\n$expansion", inlining, show = true) {
 
-      //println(i"body = $rhsToInline")
-      //println(i"expansion = $expansion")
+      // println(i"body = $rhsToInline")
 
       // The final expansion runs a typing pass over the inlined tree. See InlineTyper for details.
       val expansion1 = inlineTyper.typed(expansion, pt)(inlineCtx)
 
-      //println(i"typed expansion = $expansion1")
-
       /** All bindings in `bindingsBuf` except bindings of inlineable closures */
       val bindings = bindingsBuf.toList.map(_.withPos(call.pos))
 
-      val (finalBindings, finalExpansion) = dropUnusedDefs(bindings, expansion1)
+      inlining.println(i"original bindings = $bindings%\n%")
+      inlining.println(i"original expansion = $expansion1")
 
-      //println(i"bindings buf = ${bindingsBuf.toList}%; %")
-      //println(i"bindings = ${bindings.toList}%; %")
+      val (finalBindings, finalExpansion) = dropUnusedDefs(bindings, expansion1)
 
       tpd.Inlined(call, finalBindings, finalExpansion)
     }