Construct ref more correctly

Author: som-snytt

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

@@ -4352,23 +4352,22 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         val allDenots = ref.denot.alternatives
         if pt.isExtensionApplyProto then allDenots.filter(_.symbol.is(ExtensionMethod))
         else allDenots
+      def altRef(alt: SingleDenotation) = TermRef(ref.prefix, ref.name, alt)
+      val alts = altDenots.map(altRef)
 
       typr.println(i"adapt overloaded $ref with alternatives ${altDenots map (_.info)}%\n\n %")
 
       /** Search for an alternative that does not take parameters.
        *  If there is one, return it, otherwise return the error tree.
        */
-      def tryParameterless(alts: List[TermRef])(error: => tpd.Tree): Tree =
+      def tryParameterless(error: => tpd.Tree): Tree =
         alts.filter(_.info.isParameterless) match
         case alt :: Nil => readaptSimplified(tree.withType(alt))
         case _ =>
           altDenots.find(_.info.paramInfoss == ListOfNil) match
-          case Some(alt) => readaptSimplified(tree.withType(alt.symbol.denot.termRef))
+          case Some(alt) => readaptSimplified(tree.withType(altRef(alt)))
           case _ => error
 
-      def altRef(alt: SingleDenotation) = TermRef(ref.prefix, ref.name, alt)
-      val alts = altDenots.map(altRef)
-
       resolveOverloaded(alts, pt) match
       case alt :: Nil =>
         readaptSimplified(tree.withType(alt))
@@ -4384,7 +4383,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           // insert apply or convert qualifier, but only for a regular application
           tryInsertApplyOrImplicit(tree, pt, locked)(errorNoMatch)
         case _ =>
-          tryParameterless(alts)(errorNoMatch)
+          tryParameterless(errorNoMatch)
       case ambiAlts =>
         // If there are ambiguous alternatives, and:
         // 1. the types aren't erroneous
@@ -4410,7 +4409,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         case _: FunProto =>
           errorAmbiguous
         case _ =>
-          tryParameterless(alts)(errorAmbiguous)
+          tryParameterless(errorAmbiguous)
     end adaptOverloaded
 
     def adaptToArgs(wtp: Type, pt: FunProto): Tree = wtp match {

tests/pos/i24631/TestJava.java

@@ -0,0 +1,12 @@
+package example;
+
+public abstract class TestJava<T> {
+  public abstract T create(String foo);
+
+  // Note that this is the method that's called from Scala code
+  public T create() { return create(""); }
+
+  public static class Concrete extends TestJava<String> {
+    @Override public String create(String foo) { return foo; }
+  }
+}

tests/pos/i24631/test.scala

@@ -0,0 +1,2 @@
+val s = new example.TestJava.Concrete().create
+val s2: String = s

tests/pos/i24631b.scala

@@ -0,0 +1,11 @@
+//> using options -source:3.0-migration
+
+abstract class C[A]:
+  def create(s: String): A
+  def create(): A = create("")
+
+class D extends C[String]:
+  def create(s: String): String = s
+
+val s = D().create
+val s2: String = s