Remove unneeded abstractions

Author: nicolasstucki

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

@@ -2713,8 +2713,8 @@ object Types {
 
     def companion: MethodTypeCompanion
 
-    final override def isJavaMethod: Boolean = companion.isJava
-    final override def isImplicitMethod: Boolean = companion.isImplicit
+    final override def isJavaMethod: Boolean = companion eq JavaMethodType
+    final override def isImplicitMethod: Boolean = companion eq ImplicitMethodType
 
     val paramInfos = paramInfosExp(this)
     val resType = resultTypeExp(this)
@@ -2796,9 +2796,6 @@ object Types {
 
   abstract class MethodTypeCompanion extends TermLambdaCompanion[MethodType] { self =>
 
-    def isJava: Boolean = false
-    def isImplicit: Boolean = false
-
     /** Produce method type from parameter symbols, with special mappings for repeated
      *  and inline parameters:
      *   - replace @repeated annotations on Seq or Array types by <repeated> types
@@ -2842,21 +2839,9 @@ object Types {
     }
   }
 
-  object MethodType extends MethodTypeCompanion {
-    def withKind(isJava: Boolean = false, isImplicit: Boolean = false): MethodTypeCompanion = {
-      if (isJava) JavaMethodType
-      else if (isImplicit) ImplicitMethodType
-      else MethodType
-    }
-  }
-
-  object JavaMethodType extends MethodTypeCompanion {
-    override def isJava: Boolean = true
-  }
-
-  object ImplicitMethodType extends MethodTypeCompanion {
-    override def isImplicit: Boolean = true
-  }
+  object MethodType extends MethodTypeCompanion
+  object JavaMethodType extends MethodTypeCompanion
+  object ImplicitMethodType extends MethodTypeCompanion
 
   /** A ternary extractor for MethodType */
   object MethodTpe {

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -774,7 +774,8 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
         def isImplicit =
           tag == IMPLICITMETHODtpe ||
           params.nonEmpty && (params.head is Implicit)
-        MethodType.withKind(isImplicit = isImplicit).fromSymbols(params, restpe)
+        val maker = if (isImplicit) ImplicitMethodType else MethodType
+        maker.fromSymbols(params, restpe)
       case POLYtpe =>
         val restpe = readTypeRef()
         val typeParams = until(end, readSymbolRef)

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

@@ -107,11 +107,14 @@ trait NamerContextOps { this: Context =>
   def methodType(typeParams: List[Symbol], valueParamss: List[List[Symbol]], resultType: Type, isJava: Boolean = false)(implicit ctx: Context): Type = {
     val monotpe =
       (valueParamss :\ resultType) { (params, resultType) =>
-        val isImplicit = params.nonEmpty && (params.head is Implicit)
+        val make =
+          if (params.nonEmpty && (params.head is Implicit)) ImplicitMethodType
+          else if (isJava) JavaMethodType
+          else MethodType
         if (isJava)
           for (param <- params)
             if (param.info.isDirectRef(defn.ObjectClass)) param.info = defn.AnyType
-        MethodType.withKind(isJava, isImplicit).fromSymbols(params.asInstanceOf[List[TermSymbol]], resultType)
+        make.fromSymbols(params.asInstanceOf[List[TermSymbol]], resultType)
       }
     if (typeParams.nonEmpty) PolyType.fromParams(typeParams.asInstanceOf[List[TypeSymbol]], monotpe)
     else if (valueParamss.isEmpty) ExprType(monotpe)