Unify Type.isJavaMethod with MethodType.isJava

Author: nicolasstucki

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

@@ -398,7 +398,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
       ctx.typeComparer.orType(this(tp1), this(tp2), erased = true)
     case tp: MethodType =>
       def paramErasure(tpToErase: Type) =
-        erasureFn(tp.isJava, semiEraseVCs, isConstructor, wildcardOK)(tpToErase)
+        erasureFn(tp.isJavaMethod, semiEraseVCs, isConstructor, wildcardOK)(tpToErase)
       val (names, formals0) =
         if (tp.paramInfos.exists(_.isPhantom)) tp.paramNames.zip(tp.paramInfos).filterNot(_._2.isPhantom).unzip
         else (tp.paramNames, tp.paramInfos)

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

@@ -289,10 +289,7 @@ object Types {
     final def isAlias: Boolean = this.isInstanceOf[TypeAlias]
 
     /** Is this a MethodType which is from Java */
-    final def isJavaMethod: Boolean = this match {
-      case mt: MethodType => mt.isJava
-      case _ => false
-    }
+    def isJavaMethod: Boolean = false
 
     /** Is this a MethodType which has implicit parameters */
     final def isImplicitMethod: Boolean = this match {
@@ -1329,7 +1326,7 @@ object Types {
       case mt: MethodType if !mt.isDependent || ctx.mode.is(Mode.AllowDependentFunctions) =>
         val formals1 = if (dropLast == 0) mt.paramInfos else mt.paramInfos dropRight dropLast
         defn.FunctionOf(
-          formals1 mapConserve (_.underlyingIfRepeated(mt.isJava)), mt.resultType, mt.isImplicit && !ctx.erasedTypes)
+          formals1 mapConserve (_.underlyingIfRepeated(mt.isJavaMethod)), mt.resultType, mt.isImplicit && !ctx.erasedTypes)
     }
 
     /** The signature of this type. This is by default NotAMethod,
@@ -2697,15 +2694,15 @@ object Types {
     def kind: MethodKind
     final def companion: MethodTypeCompanion = MethodType.withKind(kind)
 
-    final def isJava: Boolean = kind is JavaKind
+    final override def isJavaMethod: Boolean = kind is JavaKind
     final def isImplicit: Boolean = kind is ImplicitKind
 
     val paramInfos = paramInfosExp(this)
     val resType = resultTypeExp(this)
     assert(resType.exists)
 
     def computeSignature(implicit ctx: Context): Signature =
-      resultSignature.prepend(paramInfos, isJava)
+      resultSignature.prepend(paramInfos, isJavaMethod)
 
     protected def prefixString = "MethodType"
   }

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

@@ -54,7 +54,7 @@ class ElimRepeated extends MiniPhaseTransform with InfoTransformer with Annotati
       val resultType1 = elimRepeated(resultType)
       val paramTypes1 =
         if (paramTypes.nonEmpty && paramTypes.last.isRepeatedParam) {
-          val last = paramTypes.last.underlyingIfRepeated(tp.isJava)
+          val last = paramTypes.last.underlyingIfRepeated(tp.isJavaMethod)
           paramTypes.init :+ last
         } else paramTypes
       tp.derivedLambdaType(paramNames, paramTypes1, resultType1)

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

@@ -557,7 +557,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
       typedArgBuf.trimEnd(n)
       val elemtpt = TypeTree(elemFormal)
       val seqLit =
-        if (methodType.isJava) JavaSeqLiteral(args, elemtpt)
+        if (methodType.isJavaMethod) JavaSeqLiteral(args, elemtpt)
         else SeqLiteral(args, elemtpt)
       typedArgBuf += seqToRepeated(seqLit)
     }

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

@@ -116,7 +116,7 @@ object ErrorReporting {
       def dropJavaMethod(tp: Type): Type = tp match {
         case tp: PolyType =>
           tp.derivedLambdaType(resType = dropJavaMethod(tp.resultType))
-        case tp: MethodType if tp.isJava =>
+        case tp: MethodType if tp.isJavaMethod =>
           MethodType(tp.paramNames, tp.paramInfos, dropJavaMethod(tp.resultType))
         case tp => tp
       }