Merge pull request scala#1781 from dotty-staging/fix-#1776

Fix scala#1776: Avoid interaction between parameter forwarding and elimByName

Author: DarkDimius

compiler/src/dotty/tools/dotc/transform/ParamForwarding.scala

@@ -55,7 +55,9 @@ class ParamForwarding(thisTransformer: DenotTransformer) {
         stat match {
           case stat: ValDef =>
             val sym = stat.symbol.asTerm
-            if (sym is (ParamAccessor, butNot = Mutable)) {
+            if (sym.is(ParamAccessor, butNot = Mutable) && !sym.info.isInstanceOf[ExprType]) {
+              // ElimByName gets confused with methods returning an ExprType,
+              // so avoid param forwarding if parameter is by name. See i1766.scala
               val idx = superArgs.indexWhere(_.symbol == sym)
               if (idx >= 0 && superParamNames(idx) == stat.name) { // supercall to like-named parameter
                 val alias = inheritedAccessor(sym)

tests/pos/i1776.scala

@@ -0,0 +1,3 @@
+class X(val y: String)
+class Y(y: => String) extends X(y)
+class Z(z: => String) extends X(z)

tests/run/implicitFuns.scala

@@ -0,0 +1,55 @@
+object Test {
+  def main(args: Array[String]) = {
+
+    implicit val world: String = "world!"
+
+    val i1 = (implicit (s: String) => s.length > 2)
+    val i2 = {implicit (s: String) => s.length > 2}
+
+    assert(i1)
+    assert(i2)
+
+    val x: implicit String => Boolean = { implicit (s: String) => s.length > 2 }
+
+    val xx: implicit (String, Int) => Int = implicit (x: String, y: Int) => x.length + y
+
+    val y: String => Boolean = x
+
+    object nested {
+      implicit val empty: String = ""
+      assert(!x)
+    }
+
+    val yy: (String, Int) => Any = xx
+
+    val z1: implicit String => Boolean = implicitly[String].length >= 2
+    assert(z1)
+
+    type StringlyBool = implicit String => Boolean
+
+    val z2: StringlyBool = implicitly[String].length >= 2
+    assert(z2)
+
+    type Stringly[T] = implicit String => T
+
+    val z3: Stringly[Boolean] = implicitly[String].length >= 2
+    assert(z3)
+
+    type GenericImplicit[X] = implicit X => Boolean
+
+    val z4: GenericImplicit[String] = implicitly[String].length >= 2
+    assert(z4)
+
+    val b = x("hello")
+
+    val b1: Boolean = b
+
+    val bi = x
+
+    val bi1: Boolean = bi
+
+    val c = xx("hh", 22)
+
+    val c1: Int = c
+  }
+}