Redo transparent overloading resolution also for Idents as refs

So far this was only done if the reference was a Select.

Author: odersky

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

@@ -307,27 +307,36 @@ object PrepareTransparent {
       }
 
       def traverse(tree: Tree)(implicit ctx: Context): Unit = {
+        val sym = tree.symbol
         tree match {
           case Ident(nme.WILDCARD) =>
           case _: Ident | _: This =>
             //println(i"leaf: $tree at ${tree.pos}")
-            if (tree.symbol.exists && !isLocal(tree.symbol, inlineMethod)) {
+            if (sym.exists && !isLocal(sym, inlineMethod)) {
               if (ctx.debug) inlining.println(i"type at $tree @ ${tree.pos.toSynthetic} = ${tree.tpe}")
-              typeAtPos(tree.pos.toSynthetic) = tree.tpe
+              tree.tpe match {
+                case tp: NamedType if tp.prefix.member(sym.name).isOverloaded =>
+                  // refer to prefix instead of to ident directly, so that overloading can be resolved
+                  // again at expansion site
+                  println(i"RECORD start for $tree")
+                  typeAtPos(tree.pos.startPos) = tp.prefix
+                case _ =>
+                  typeAtPos(tree.pos.toSynthetic) = tree.tpe
+              }
                 // Note: It's possible that during traversals several types are stored under the same
                 // position. This could happen for instance for implicit conersions added around a tree.
                 // In general, it's always the innermost tree that holds the relevant type. The traversal
                 // order guarantees that the innermost tree's type is stored last, and thereby replaces all previously
                 // stored types.
             }
           case _: Select =>
-            tree.symbol.name match {
+            sym.name match {
               case InlineAccessorName(UniqueInlineName(_, _)) => return // was already recorded in Apply
               case InlineAccessorName(_) => registerAccessor(tree)
               case _ =>
             }
           case Apply(_: RefTree | _: TypeApply, receiver :: Nil) =>
-            tree.symbol.name match {
+            sym.name match {
               case InlineAccessorName(UniqueInlineName(_, _)) => registerAccessor(tree)
               case _ =>
             }

tests/pos/transparent-overload.scala

@@ -0,0 +1,22 @@
+object Test {
+
+  def f(x: Int): Int = x
+  def f(x: String): String = x
+  def f(x: Any): Any = x
+
+  transparent def g(x: Any) = f(x)
+  transparent def h(x: Any) = this.f(x)
+
+  locally {
+    val x1 = g(1)
+    val x2 = g("bb")
+    val y1: Int = x1
+    val y2: String = x2
+  }
+  locally {
+    val x1 = h(1)
+    val x2 = h("bb")
+    val y1: Int = x1
+    val y2: String = x2
+  }
+}