Use FUNmode and wild pt in typing the m in m _

We'll use the expected type when we type the eta-expansion
that was requested.

We know `m` is expected to be a method, since only methods
can be followed by `_` to request eta-expansion. So,
have the expected type reflect that. Since the original
expected type won't be compatible with the method type
that FUNmode gives us (method values are not first class),
we have to defer using the given expected type until we
eta-expanded, which results in a function, which is first class.

When typing under FUNmode under pt=* we can let implicit
conversion do its thing, before we wrap this in a function.

See scala/bug#8299.

Author: adriaanm

src/compiler/scala/tools/nsc/typechecker/Typers.scala

@@ -5373,7 +5373,15 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
           // because `expr` might contain nested macro calls (see scala/bug#6673).
           // Otherwise, (check for dead code, and) eta-expand.
           case MethodValue(expr) =>
-            typed1(suppressMacroExpansion(expr), mode, pt) match {
+            // Need to type in FUNmode so that we accept a method type (which also means we can't use our pt),
+            // this does mean no overloading is performed. The main reason to ignore pt and move to FUNmode is that
+            // the `m` in `m _` could involve an implicit conversion, which will go through adapt after converting,
+            // which will run afoul of the restriction that a method-typed tree is only allowed when a function type is expected.
+            // We peeled off the `_` marker for the typed1 call, so we don't know that the user has requested eta-expansion.
+            // See scala/bug#8299.
+            val funTyped = typed1(suppressMacroExpansion(expr), mode | FUNmode, WildcardType)
+            if (funTyped.tpe.isInstanceOf[OverloadedType]) inferExprAlternative(funTyped, pt)
+            funTyped match {
               case macroDef if treeInfo.isMacroApplication(macroDef) => MacroEtaError(macroDef)
               case methodValue                                       => typedEta(checkDead(methodValue))
             }

test/files/pos/t8299.scala

@@ -0,0 +1,18 @@
+object Test extends App {
+  class C
+
+  implicit class CompatibleC(c: C) {
+    def foo(x: Int) = ???
+  }
+
+  val c: C = ???
+  println(c.foo _)
+
+  object B {
+    def f(x: Int) = x
+    def f(x: String) = x
+  }
+
+  val fun: Int => Int = B.f _
+  val funs: String => String = B.f _
+}