Handle transparent implicits in implicit context

When adding implicit bindings to an implicit context of an inline
body, we need to maintain the transparency of the implicits.

The added implicit bindings are eliminated after inlining,
since they are either unused or have been inlined.

Author: odersky

compiler/src/dotty/tools/dotc/core/Flags.scala

@@ -560,6 +560,9 @@ object Flags {
   /** A transparent method */
   final val TransparentMethod = allOf(Transparent, Method)
 
+  /** A transparent implicit method */
+  final val TransparentImplicitMethod = allOf(Transparent, Implicit, Method)
+
   /** A transparent parameter */
   final val TransparentParam = allOf(Transparent, Param)
 

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

@@ -793,6 +793,14 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
     }
     countRefs.traverse(tree)
     for (binding <- bindings) countRefs.traverse(binding)
+
+    def retain(boundSym: Symbol) = {
+      refCount.get(boundSym) match {
+        case Some(x) => x > 1 || x == 1 && !boundSym.is(Method)
+        case none => true
+      }
+    } && !boundSym.is(TransparentImplicitMethod)
+
     val inlineBindings = new TreeMap {
       override def transform(t: Tree)(implicit ctx: Context) = t match {
         case t: RefTree =>
@@ -812,11 +820,8 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
           super.transform(t)
       }
     }
-    def retain(binding: MemberDef) = refCount.get(binding.symbol) match {
-      case Some(x) => x > 1 || x == 1 && !binding.symbol.is(Method)
-      case none => true
-    }
-    val retained = bindings.filterConserve(retain)
+
+    val retained = bindings.filterConserve(binding => retain(binding.symbol))
     if (retained `eq` bindings) {
       (bindings, tree)
     }

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

@@ -287,7 +287,7 @@ object PrepareTransparent {
            !isLocalOrParam(tree.symbol, inlineMethod) &&
            !implicitRefTypes.contains(tree.tpe) =>
           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)
+            ctx.warning(i"implicit reference $tree is dropped at inline site because it refers to local symbol(s)", tree.pos)
           else {
             implicitRefTypes += tree.tpe
             implicitRefs += tree
@@ -417,11 +417,23 @@ object PrepareTransparent {
         val localImplicit = iref.symbol.asTerm.copy(
           owner = inlineMethod,
           name = UniqueInlineName.fresh(iref.symbol.name.asTermName),
-          flags = Implicit | Method | Stable,
+          flags = Implicit | Method | Stable | iref.symbol.flags & (Transparent | Erased),
           info = iref.tpe.widen.ensureMethodic,
           coord = inlineMethod.pos).asTerm
-        polyDefDef(localImplicit, tps => vrefss =>
+        val idef = polyDefDef(localImplicit, tps => vrefss =>
             iref.appliedToTypes(tps).appliedToArgss(vrefss))
+        if (localImplicit.is(Transparent)) {
+          // produce a Body annotation for inlining
+          def untype(tree: Tree): untpd.Tree = tree match {
+            case Apply(fn, args) => untpd.cpy.Apply(tree)(untype(fn), args)
+            case TypeApply(fn, args) => untpd.cpy.TypeApply(tree)(untype(fn), args)
+            case _ => untpd.TypedSplice(tree)
+          }
+          val inlineBody = tpd.UntypedSplice(untype(idef.rhs)).withType(idef.rhs.tpe)
+          inlining.println(i"body annot for $idef: $inlineBody")
+          localImplicit.addAnnotation(ConcreteBodyAnnotation(inlineBody))
+        }
+        idef
       }
     val untpdSplice = tpd.UntypedSplice(addRefs.transform(original)).withType(typed.tpe)
     seq(implicitBindings, untpdSplice)