Don't rely on JavaMethodType to use Java signatures

Before this commit, SingleDenotation#signature simply delegated to
MethodOrPoly#signature which used Java signatures for JavaMethodType and
non-Java signatures otherwise. As a first step towards getting rid of
JavaMethodType, this commit changes this to make
SingleDenotation#signature itself responsible for using Java signatures.

Author: smarter

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

@@ -582,11 +582,23 @@ object Denotations {
      */
     def prefix: Type = NoPrefix
 
+    /** Either the Scala or Java signature of the info, depending on where the
+     *  symbol is defined.
+     *
+     *  Invariants:
+     *  - Before erasure, the signature of a denotation is always equal to the
+     *    signature of its corresponding initial denotation.
+     *  - Two distinct overloads will have SymDenotations with distinct
+     *    signatures (the SELECTin tag in Tasty relies on this to refer to an
+     *    overload unambiguously). Note that this only applies to
+     *    SymDenotations, in general we cannot assume that distinct
+     *    SingleDenotations will have distinct signatures (cf #9050).
+     */
     final def signature(using Context): Signature =
-      if (isType) Signature.NotAMethod // don't force info if this is a type SymDenotation
+      if (isType) Signature.NotAMethod // don't force info if this is a type denotation
       else info match {
-        case info: MethodicType =>
-          try info.signature
+        case info: MethodOrPoly =>
+          try info.signature(isJava = symbol.is(JavaDefined))
           catch { // !!! DEBUG
             case scala.util.control.NonFatal(ex) =>
               report.echo(s"cannot take signature of $info")

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

@@ -3405,12 +3405,12 @@ object Types {
         mySignature
     end signature
 
+    /** The Scala signature of this method. Note that two distinct Java method
+     *  overloads may have the same Scala signature, the other overload of
+     *  `signature` can be used to avoid ambiguity if necessary.
+     */
     final override def signature(using Context): Signature =
-      def isJava(tp: Type): Boolean = tp match
-        case tp: PolyType => isJava(tp.resultType)
-        case tp: MethodType => tp.isJavaMethod
-        case _ => false
-      signature(isJava = isJava(this))
+      signature(isJava = false)
 
     final override def hashCode: Int = System.identityHashCode(this)