Streamline companion selection in MethodType

Author: odersky

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

@@ -128,10 +128,10 @@ class Definitions {
           enterTypeParam(cls, paramNamePrefix ++ "T" ++ (i + 1).toString, Contravariant, decls).typeRef
         }
         val resParamRef = enterTypeParam(cls, paramNamePrefix ++ "R", Covariant, decls).typeRef
-        val methodType = MethodType.maker(
+        val methodType = MethodType.companion(
           isJava = false,
-          isOldImplicit = false,
           isContextual = name.isImplicitFunction,
+          isOldImplicit = false,
           isErased = name.isErasedFunction)
         decls.enter(newMethod(cls, nme.apply, methodType(argParamRefs, resParamRef), Deferred))
         denot.info =

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

@@ -3285,7 +3285,7 @@ object Types {
   }
 
   object MethodType extends MethodTypeCompanion("MethodType") {
-    def maker(isJava: Boolean = false, isOldImplicit: Boolean = false, isErased: Boolean = false, isContextual: Boolean = false): MethodTypeCompanion = {
+    def companion(isJava: Boolean = false, isContextual: Boolean = false, isOldImplicit: Boolean = false, isErased: Boolean = false): MethodTypeCompanion = {
       if (isJava) {
         assert(!isOldImplicit)
         assert(!isErased)

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

@@ -767,10 +767,8 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
       case METHODtpe | IMPLICITMETHODtpe =>
         val restpe = readTypeRef()
         val params = until(end, () => readSymbolRef())
-        val isOldImplicit =
-          tag == IMPLICITMETHODtpe ||
-          params.nonEmpty && (params.head is OldImplicit)
-        val maker = MethodType.maker(isOldImplicit = isOldImplicit)
+        val maker = MethodType.companion(
+          isOldImplicit = tag == IMPLICITMETHODtpe || params.nonEmpty && (params.head is OldImplicit))
         maker.fromSymbols(params, restpe)
       case POLYtpe =>
         val restpe = readTypeRef()

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

@@ -137,7 +137,7 @@ trait NamerContextOps { this: Context =>
         val (isOldImplicit, isErased, isContextual) =
           if (params.isEmpty) (false, false, false)
           else (params.head is OldImplicit, params.head is Erased, params.head.is(Given))
-        val make = MethodType.maker(isJava = isJava, isOldImplicit = isOldImplicit, isErased = isErased, isContextual = isContextual)
+        val make = MethodType.companion(isJava = isJava, isContextual = isContextual, isOldImplicit = isOldImplicit, isErased = isErased)
         if (isJava)
           for (param <- params)
             if (param.info.isDirectRef(defn.ObjectClass)) param.info = defn.AnyType

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

@@ -819,7 +819,7 @@ class Typer extends Namer
       if (!funFlags.isEmpty)
         params1.foreach(_.symbol.setFlag(funFlags))
       val resultTpt = typed(body)
-      val companion = MethodType.maker(
+      val companion = MethodType.companion(
           isContextual = funFlags.is(Given), isErased = funFlags.is(Erased))
       val mt = companion.fromSymbols(params1.map(_.symbol), resultTpt.tpe)
       if (mt.isParamDependent)