Drop "not an extension method" check

The test was supposed to check that extension method resolution did
produce an extension method and not a normal method. But that test
only gave false negatives, as test sticky-extension method shows.

Author: odersky

compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala

@@ -168,8 +168,7 @@ enum ErrorMessageID extends java.lang.Enum[ErrorMessageID] {
     CannotExtendJavaEnumID,
     InvalidReferenceInImplicitNotFoundAnnotationID,
     TraitMayNotDefineNativeMethodID,
-    JavaEnumParentArgsID,
-    NotAnExtensionMethodID
+    JavaEnumParentArgsID
 
   def errorNumber = ordinal - 2
 }

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -2402,11 +2402,6 @@ import transform.SymUtils._
            |""".stripMargin
   }
 
-  class NotAnExtensionMethod(methodRef: untpd.Tree)(using Context)
-    extends TypeMsg(NotAnExtensionMethodID):
-    def msg = em"not an extension method: $methodRef"
-    def explain = ""
-
   class NoExtensionMethodAllowed(mdef: untpd.DefDef)(using Context)
     extends SyntaxMsg(NoExtensionMethodAllowedID) {
     def msg = em"No extension method allowed here, since collective parameters are given"

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

@@ -2153,18 +2153,11 @@ trait Applications extends Compatibility {
         (tree, currentPt)
 
     val (core, pt1) = normalizePt(methodRef, pt)
-    val app = withMode(Mode.SynthesizeExtMethodReceiver) {
+    withMode(Mode.SynthesizeExtMethodReceiver) {
       typed(
         untpd.Apply(core, untpd.TypedSplice(receiver, isExtensionReceiver = true) :: Nil),
         pt1, ctx.typerState.ownedVars)
     }
-    def isExtension(tree: Tree): Boolean = methPart(tree) match {
-      case Inlined(call, _, _) => isExtension(call)
-      case tree @ Select(qual, nme.apply) => tree.symbol.is(ExtensionMethod) || isExtension(qual)
-      case tree => tree.symbol.is(ExtensionMethod)
-    }
-    if !isExtension(app) then report.error(NotAnExtensionMethod(methodRef), receiver.srcPos)
-    app
   }
 
   def isApplicableExtensionMethod(ref: TermRef, receiver: Type)(using Context) =

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

@@ -3513,12 +3513,9 @@ class Typer extends Namer
               nestedCtx.typerState.commit()
               return ExtMethodApply(app)
             else
-              nestedCtx.reporter.allErrors
-                .filterNot(_.msg.isInstanceOf[NotAnExtensionMethod]) match
-                case Nil =>
-                case err :: _ =>
-                  rememberSearchFailure(tree,
-                    SearchFailure(app.withType(FailedExtension(app, pt, err.msg))))
+              for err <- nestedCtx.reporter.allErrors.take(1) do
+                rememberSearchFailure(tree,
+                  SearchFailure(app.withType(FailedExtension(app, pt, err.msg))))
           catch case ex: TypeError =>
             rememberSearchFailure(tree,
               SearchFailure(tree.withType(NestedFailure(ex.toMessage, pt))))

tests/run/eta-extension.scala

@@ -0,0 +1,6 @@
+extension (s: String) def times(i: Int): String = s * i
+
+val partial = "abc".times
+
+@main def Test =
+  assert(partial(2) == "abcabc")

tests/run/sticky-extmethod.check

@@ -0,0 +1 @@
+1

tests/run/sticky-extmethod.scala

@@ -0,0 +1,5 @@
+
+extension (x: Int) def m (y: Object): Int = x
+def m (x: Int)(y: String): String = y * x
+
+@main def Test = println(1.m("xx"))