Fix #4600: method could be inside block in argument implicit resolution

Author: liufengyun

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

@@ -2250,6 +2250,12 @@ class Typer extends Namer
           untpd.Apply(tree, args).withType(propFail)
         }
 
+        // lifting may result in blocks, see tests/pos/i4600b.scala
+        def methSymbol: Symbol = tree match {
+          case Block(_, expr) => expr.symbol
+          case _              => tree.symbol
+        }
+
         if (propFail.exists) {
           // If there are several arguments, some arguments might already
           // have influenced the context, binding variables, but later ones
@@ -2258,7 +2264,7 @@ class Typer extends Namer
 
           // If method has default params, fall back to regular application
           // where all inferred implicits are passed as named args.
-          if (tree.symbol.hasDefaultParams && !propFail.isInstanceOf[AmbiguousImplicits]) {
+          if (methSymbol.hasDefaultParams && !propFail.isInstanceOf[AmbiguousImplicits]) {
             val namedArgs = (wtp.paramNames, args).zipped.flatMap { (pname, arg) =>
               if (arg.tpe.isError) Nil else untpd.NamedArg(pname, untpd.TypedSplice(arg)) :: Nil
             }

tests/pos/i4600.scala

@@ -0,0 +1,26 @@
+import scala.language.dynamics
+
+class ImplicitExample() extends Dynamic {
+  def someMethod()(implicit s: String = "World"): String = s
+  def applyDynamic(name: String)(args: Any*)(implicit s: String = "World"): String = name + s
+}
+
+class ImplicitTest {
+  def t1(): Unit = {
+    new ImplicitExample().someMethod()
+  }
+
+  def t2(): Unit = {
+    implicit val s: String = "Hello"
+    new ImplicitExample().someMethod()
+  }
+
+  def t3(): Unit = {
+    new ImplicitExample().run()
+  }
+
+  def t4(): Unit = {
+    implicit val s: String = "Hello"
+    new ImplicitExample().run()
+  }
+}

tests/pos/i4600b.scala

@@ -0,0 +1,12 @@
+class Foo(config: String) {
+  case class Bar(val x: Int) {
+    def doThings: String = config //Do whatever here
+  }
+}
+
+
+object Test {
+  def test(foo: Foo)(bar: foo.Bar = foo.Bar(5))(implicit s: String = "ok") = ???
+
+  test(new Foo("port"))()
+}