Fix #2000: Make implicit and non-implicit functions incomparable

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

@@ -489,7 +489,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
         case tp1 @ MethodType(_, formals1) =>
           (tp1.signature consistentParams tp2.signature) &&
             matchingParams(formals1, formals2, tp1.isJava, tp2.isJava) &&
-            (!tp1.isImplicit || tp2.isImplicit) &&  // non-implicit functions shadow implicit ones
+            (tp1.isImplicit == tp2.isImplicit) &&
             isSubType(tp1.resultType, tp2.resultType.subst(tp2, tp1))
         case _ =>
           false

compiler/test/dotc/tests.scala

@@ -184,6 +184,7 @@ class tests extends CompilerTest {
   @Test def neg_autoTupling = compileFile(negCustomArgs, "autoTuplingTest", args = "-language:noAutoTupling" :: Nil)
   @Test def neg_i1050 = compileFile(negCustomArgs, "i1050", List("-strict"))
   @Test def neg_i1240 = compileFile(negCustomArgs, "i1240")(allowDoubleBindings)
+  @Test def neg_i2002 = compileFile(negCustomArgs, "i2002")(allowDoubleBindings)
 
   val negTailcallDir = negDir + "tailcall/"
   @Test def neg_tailcall_t1672b = compileFile(negTailcallDir, "t1672b")

tests/neg/customArgs/i2002.scala

@@ -0,0 +1,4 @@
+class Test {
+  def foo(i: Int): Int = i
+  def foo(implicit i: Int): Int = i // error
+}

tests/neg/i2000.scala

@@ -0,0 +1,23 @@
+object test1 {
+  class C[A] { def foo(a: A) = "c" }
+  class D extends C[String] { override def foo(implicit s: String) = "d" } // error
+}
+
+object test2 {
+  class C[A] { final def foo(a: A) = "c" }
+  class D extends C[String] { def foo(implicit s: String) = "d" } // error
+  object Test {
+    def main(args: Array[String]) =
+      new D
+  }
+}
+
+object test3 {
+  class A {
+    def foo(implicit i: Int): Int = i + i
+  }
+
+  class B extends A {
+    override def foo(i: Int): Int = i // error
+  }
+}