Get rid of JavaMethodType

This is possible thanks to the previous commit, in all remaining places
where we called `isJavaMethod` we can rely on contextual informations to
obtain the same information, so we can completely get rid of it which is
a nice simplification.

Also get rid of ElimRepeated#transformTypeOfTree which turned out to be
a no-op: the denotation transformer already transforms method types and
there's nothing to do on top of that.

Author: smarter

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

@@ -122,7 +122,6 @@ class Definitions {
         }
         val resParamRef = enterTypeParam(cls, paramNamePrefix ++ "R", Covariant, decls).typeRef
         val methodType = MethodType.companion(
-          isJava = false,
           isContextual = name.isContextFunction,
           isImplicit = false,
           isErased = name.isErasedFunction)

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

@@ -39,7 +39,7 @@ object NamerOps:
         val (isContextual, isImplicit, isErased) =
           if params.isEmpty then (false, false, false)
           else (params.head.is(Given), params.head.is(Implicit), params.head.is(Erased))
-        val make = MethodType.companion(isJava = isJava, isContextual = isContextual, isImplicit = isImplicit, isErased = isErased)
+        val make = MethodType.companion(isContextual = isContextual, isImplicit = isImplicit, isErased = isErased)
         if isJava then
           for param <- params do
             if param.info.isDirectRef(defn.ObjectClass) then param.info = defn.AnyType

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

@@ -249,8 +249,7 @@ object TypeErasure {
       !classify(tp).derivesFrom(defn.ObjectClass) &&
       !tp.symbol.is(JavaDefined)
     case tp: TypeParamRef =>
-      !classify(tp).derivesFrom(defn.ObjectClass) &&
-      !tp.binder.resultType.isJavaMethod
+      !classify(tp).derivesFrom(defn.ObjectClass)
     case tp: TypeAlias => isUnboundedGeneric(tp.alias)
     case tp: TypeBounds =>
       val upper = classify(tp.hi)
@@ -474,7 +473,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
       TypeComparer.orType(this(tp1), this(tp2), isErased = true)
     case tp: MethodType =>
       def paramErasure(tpToErase: Type) =
-        erasureFn(tp.isJavaMethod, semiEraseVCs, isConstructor, wildcardOK)(tpToErase)
+        erasureFn(isJava, semiEraseVCs, isConstructor, wildcardOK)(tpToErase)
       val (names, formals0) = if (tp.isErasedMethod) (Nil, Nil) else (tp.paramNames, tp.paramInfos)
       val formals = formals0.mapConserve(paramErasure)
       eraseResult(tp.resultType) match {

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

@@ -77,9 +77,7 @@ object Types {
    *        +- GroundType -+- AndType
    *                       +- OrType
    *                       +- MethodOrPoly ---+-- PolyType
-   *                                          +-- MethodType ---+- ImplicitMethodType
-   *                                                            +- ContextualMethodType
-   *                       |                                    +- JavaMethodType
+   *                       |                  +-- MethodType
    *                       +- ClassInfo
    *                       |
    *                       +- NoType
@@ -400,9 +398,6 @@ object Types {
     /** Is this an alias TypeBounds? */
     final def isTypeAlias: Boolean = this.isInstanceOf[TypeAlias]
 
-    /** Is this a MethodType which is from Java? */
-    def isJavaMethod: Boolean = false
-
     /** Is this a Method or PolyType which has implicit or contextual parameters? */
     def isImplicitMethod: Boolean = false
 
@@ -1725,35 +1720,22 @@ object Types {
      *  @param dropLast  The number of trailing parameters that should be dropped
      *                   when forming the function type.
      */
-    def toFunctionType(dropLast: Int = 0)(using Context): Type = this match {
+    def toFunctionType(isJava: Boolean, dropLast: Int = 0)(using Context): Type = this match {
       case mt: MethodType if !mt.isParamDependent =>
         val formals1 = if (dropLast == 0) mt.paramInfos else mt.paramInfos dropRight dropLast
         val isContextual = mt.isContextualMethod && !ctx.erasedTypes
         val isErased = mt.isErasedMethod && !ctx.erasedTypes
         val result1 = mt.nonDependentResultApprox match {
-          case res: MethodType => res.toFunctionType()
+          case res: MethodType => res.toFunctionType(isJava)
           case res => res
         }
         val funType = defn.FunctionOf(
-          formals1 mapConserve (_.translateFromRepeated(toArray = mt.isJavaMethod)),
+          formals1 mapConserve (_.translateFromRepeated(toArray = isJava)),
           result1, isContextual, isErased)
         if (mt.isResultDependent) RefinedType(funType, nme.apply, mt)
         else funType
     }
 
-    final def dropJavaMethod(using Context): Type = this match
-      case pt: PolyType => pt.derivedLambdaType(resType = pt.resType.dropJavaMethod)
-
-      case mt: MethodType =>
-        if mt.isJavaMethod then
-          MethodType.apply(mt.paramNames, mt.paramInfos, mt.resType.dropJavaMethod)
-        else
-          mt.derivedLambdaType(resType = mt.resType.dropJavaMethod)
-
-      case _ => this
-
-    end dropJavaMethod
-
     /** The signature of this type. This is by default NotAMethod,
      *  but is overridden for PolyTypes, MethodTypes, and TermRef types.
      *  (the reason why we deviate from the "final-method-with-pattern-match-in-base-class"
@@ -3558,7 +3540,6 @@ object Types {
 
     def companion: MethodTypeCompanion
 
-    final override def isJavaMethod: Boolean = companion eq JavaMethodType
     final override def isImplicitMethod: Boolean =
       companion.eq(ImplicitMethodType) ||
       companion.eq(ErasedImplicitMethodType) ||
@@ -3654,21 +3635,14 @@ object Types {
   }
 
   object MethodType extends MethodTypeCompanion("MethodType") {
-    def companion(isJava: Boolean = false, isContextual: Boolean = false, isImplicit: Boolean = false, isErased: Boolean = false): MethodTypeCompanion =
-      if (isJava) {
-        assert(!isImplicit)
-        assert(!isErased)
-        assert(!isContextual)
-        JavaMethodType
-      }
-      else if (isContextual)
+    def companion(isContextual: Boolean = false, isImplicit: Boolean = false, isErased: Boolean = false): MethodTypeCompanion =
+      if (isContextual)
         if (isErased) ErasedContextualMethodType else ContextualMethodType
       else if (isImplicit)
         if (isErased) ErasedImplicitMethodType else ImplicitMethodType
       else
         if (isErased) ErasedMethodType else MethodType
   }
-  object JavaMethodType extends MethodTypeCompanion("JavaMethodType")
   object ErasedMethodType extends MethodTypeCompanion("ErasedMethodType")
   object ContextualMethodType extends MethodTypeCompanion("ContextualMethodType")
   object ErasedContextualMethodType extends MethodTypeCompanion("ErasedContextualMethodType")

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -447,7 +447,7 @@ class ClassfileParser(
 
           index += 1
           val restype = sig2type(tparams, skiptvs = false)
-          JavaMethodType(paramnames.toList, paramtypes.toList, restype)
+          MethodType(paramnames.toList, paramtypes.toList, restype)
         case 'T' =>
           val n = subName(';'.==).toTypeName
           index += 1

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

@@ -31,7 +31,7 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
   override def changesMembers: Boolean = true // the phase adds vararg forwarders
 
   def transformInfo(tp: Type, sym: Symbol)(using Context): Type =
-    elimRepeated(tp)
+    elimRepeated(tp, sym.is(JavaDefined))
 
   /** Create forwarder symbols for the methods that are annotated
    *  with `@varargs` or that override java varargs.
@@ -88,15 +88,14 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
       (sym.allOverriddenSymbols.exists(s => s.is(JavaDefined) || hasVarargsAnnotation(s)))
 
   /** Eliminate repeated parameters from method types. */
-  private def elimRepeated(tp: Type)(using Context): Type = tp.stripTypeVar match
+  private def elimRepeated(tp: Type, isJava: Boolean)(using Context): Type = tp.stripTypeVar match
     case tp @ MethodTpe(paramNames, paramTypes, resultType) =>
-      val resultType1 = elimRepeated(resultType)
+      val resultType1 = elimRepeated(resultType, isJava)
       val paramTypes1 =
         val lastIdx = paramTypes.length - 1
         if lastIdx >= 0 then
           val last = paramTypes(lastIdx)
           if last.isRepeatedParam then
-            val isJava = tp.isJavaMethod
             // We need to be careful when handling Java repeated parameters
             // of the form `Object...` or `T...` where `T` is unbounded:
             // in both cases, `Object` will have been translated to `FromJavaObject`
@@ -117,22 +116,10 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
         else paramTypes
       tp.derivedLambdaType(paramNames, paramTypes1, resultType1)
     case tp: PolyType =>
-      tp.derivedLambdaType(tp.paramNames, tp.paramInfos, elimRepeated(tp.resultType))
+      tp.derivedLambdaType(tp.paramNames, tp.paramInfos, elimRepeated(tp.resultType, isJava))
     case tp =>
       tp
 
-  def transformTypeOfTree(tree: Tree)(using Context): Tree =
-    tree.withType(elimRepeated(tree.tpe))
-
-  override def transformTypeApply(tree: TypeApply)(using Context): Tree =
-    transformTypeOfTree(tree)
-
-  override def transformIdent(tree: Ident)(using Context): Tree =
-    transformTypeOfTree(tree)
-
-  override def transformSelect(tree: Select)(using Context): Tree =
-    transformTypeOfTree(tree)
-
   override def transformApply(tree: Apply)(using Context): Tree =
     val args = tree.args.mapConserve {
       case arg: Typed if isWildcardStarArg(arg) =>
@@ -147,7 +134,7 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
           arg.expr
       case arg => arg
     }
-    transformTypeOfTree(cpy.Apply(tree)(tree.fun, args))
+    cpy.Apply(tree)(tree.fun, args)
 
   /** Convert sequence argument to Java array */
   private def seqToArray(tree: Tree)(using Context): Tree = tree match

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

@@ -377,7 +377,7 @@ class PickleQuotes extends MacroTransform {
             (tree: Tree) => {
               def newCapture = {
                 val tpw = tree.tpe.widen match {
-                  case tpw: MethodicType => tpw.toFunctionType()
+                  case tpw: MethodicType => tpw.toFunctionType(isJava = false)
                   case tpw => tpw
                 }
                 assert(tpw.isInstanceOf[ValueType])

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

@@ -628,7 +628,7 @@ trait Applications extends Compatibility {
         false
       case argtpe =>
         def SAMargOK = formal match {
-          case SAMType(sam) => argtpe <:< sam.toFunctionType()
+          case SAMType(sam) => argtpe <:< sam.toFunctionType(isJava = formal.classSymbol.is(JavaDefined))
           case _ => false
         }
         isCompatible(argtpe, formal) || ctx.mode.is(Mode.ImplicitsEnabled) && SAMargOK

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

@@ -118,12 +118,7 @@ object ErrorReporting {
 
     /** A subtype log explaining why `found` does not conform to `expected` */
     def whyNoMatchStr(found: Type, expected: Type): String = {
-      val found1 = found.dropJavaMethod
-      val expected1 = expected.dropJavaMethod
-      if ((found1 eq found) != (expected eq expected1) && (found1 <:< expected1))
-        i"""
-           |(Note that Scala's and Java's representation of this type differs)"""
-      else if (ctx.settings.explainTypes.value)
+      if (ctx.settings.explainTypes.value)
         i"""
            |${ctx.typerState.constraint}
            |${TypeComparer.explained(_.isSubType(found, expected))}"""

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

@@ -1049,7 +1049,7 @@ class Namer { typer: Typer =>
                   if sym.isStableMember && sym.isPublic && !refersToPrivate(path.tpe) then
                     (StableRealizable, ExprType(path.tpe.select(sym)))
                   else
-                    (EmptyFlags, mbr.info.ensureMethodic.dropJavaMethod)
+                    (EmptyFlags, mbr.info.ensureMethodic)
                 var mbrFlags = Exported | Method | Final | maybeStable | sym.flags & RetainedExportFlags
                 if sym.is(ExtensionMethod) then mbrFlags |= ExtensionMethod
                 val forwarderName = checkNoConflict(alias, isPrivate = false, span)

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

@@ -375,7 +375,7 @@ trait TypeAssigner {
 
   def assignType(tree: untpd.Closure, meth: Tree, target: Tree)(using Context): Closure =
     tree.withType(
-      if (target.isEmpty) meth.tpe.widen.toFunctionType(tree.env.length)
+      if (target.isEmpty) meth.tpe.widen.toFunctionType(isJava = meth.symbol.is(JavaDefined), tree.env.length)
       else target.tpe)
 
   def assignType(tree: untpd.CaseDef, pat: Tree, body: Tree)(using Context): CaseDef = {

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

@@ -3603,7 +3603,7 @@ class Typer extends Namer
         if defn.isFunctionType(wtp) && !defn.isFunctionType(pt) =>
           pt match {
             case SAMType(sam)
-            if wtp <:< sam.toFunctionType() =>
+            if wtp <:< sam.toFunctionType(isJava = pt.classSymbol.is(JavaDefined)) =>
               // was ... && isFullyDefined(pt, ForceDegree.flipBottom)
               // but this prevents case blocks from implementing polymorphic partial functions,
               // since we do not know the result parameter a priori. Have to wait until the

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -385,7 +385,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         def etaExpand(owner: Symbol): Term = self.tpe.widen match {
           case mtpe: Types.MethodType if !mtpe.isParamDependent =>
             val closureResType = mtpe.resType match {
-              case t: Types.MethodType => t.toFunctionType()
+              case t: Types.MethodType => t.toFunctionType(isJava = self.symbol.is(JavaDefined))
               case t => t
             }
             val closureTpe = Types.MethodType(mtpe.paramNames, mtpe.paramInfos, closureResType)