Renamings and simplifications

Author: odersky

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

@@ -130,7 +130,7 @@ class Definitions {
         val resParamRef = enterTypeParam(cls, paramNamePrefix ++ "R", Covariant, decls).typeRef
         val methodType = MethodType.maker(
           isJava = false,
-          isImplicit = name.isImplicitFunction,
+          isOldImplicit = false,
           isContextual = name.isImplicitFunction,
           isErased = name.isErasedFunction)
         decls.enter(newMethod(cls, nme.apply, methodType(argParamRefs, resParamRef), Deferred))

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

@@ -333,19 +333,16 @@ object Types {
     /** Is this an alias TypeBounds? */
     final def isTypeAlias: Boolean = this.isInstanceOf[TypeAlias]
 
-    /** Is this a MethodType which is from Java */
+    /** Is this a MethodType which is from Java? */
     def isJavaMethod: Boolean = false
 
-    /** Is this a MethodType which has implicit or contextual parameters */
+    /** Is this a Method or PolyType which has implicit or contextual parameters? */
     def isImplicitMethod: Boolean = false
 
     /** Is this a Method or PolyType which has contextual parameters as first value parameter list? */
     def isContextual: Boolean = false
 
-    /** Is this a Method or PolyType which has implicit parameters as first value parameter list? */
-    def isImplicit: Boolean = false
-
-    /** Is this a MethodType for which the parameters will not be used */
+    /** Is this a MethodType for which the parameters will not be used? */
     def isErasedMethod: Boolean = false
 
     /** Is this a match type or a higher-kinded abstraction of one?
@@ -3196,7 +3193,6 @@ object Types {
     final override def isContextual: Boolean =
       companion.eq(ContextualMethodType) ||
       companion.eq(ErasedContextualMethodType)
-    final override def isImplicit = isImplicitMethod
 
     def computeSignature(implicit ctx: Context): Signature = {
       val params = if (isErasedMethod) Nil else paramInfos
@@ -3289,16 +3285,16 @@ object Types {
   }
 
   object MethodType extends MethodTypeCompanion("MethodType") {
-    def maker(isJava: Boolean = false, isImplicit: Boolean = false, isErased: Boolean = false, isContextual: Boolean = false): MethodTypeCompanion = {
+    def maker(isJava: Boolean = false, isOldImplicit: Boolean = false, isErased: Boolean = false, isContextual: Boolean = false): MethodTypeCompanion = {
       if (isJava) {
-        assert(!isImplicit)
+        assert(!isOldImplicit)
         assert(!isErased)
         assert(!isContextual)
         JavaMethodType
       }
       else if (isContextual)
         if (isErased) ErasedContextualMethodType else ContextualMethodType
-      else if (isImplicit)
+      else if (isOldImplicit)
         if (isErased) ErasedImplicitMethodType else ImplicitMethodType
       else
         if (isErased) ErasedMethodType else MethodType
@@ -3389,7 +3385,7 @@ object Types {
     def computeSignature(implicit ctx: Context): Signature = resultSignature
 
     override def isContextual = resType.isContextual
-    override def isImplicit = resType.isImplicit
+    override def isImplicitMethod = resType.isImplicitMethod
 
     /** Merge nested polytypes into one polytype. nested polytypes are normally not supported
      *  but can arise as temporary data structures.

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

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

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

@@ -134,10 +134,10 @@ 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, isErased, isContextual) =
+        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, isImplicit = isImplicit, isErased = isErased, isContextual = isContextual)
+        val make = MethodType.maker(isJava = isJava, isOldImplicit = isOldImplicit, isErased = isErased, isContextual = isContextual)
         if (isJava)
           for (param <- params)
             if (param.info.isDirectRef(defn.ObjectClass)) param.info = defn.AnyType

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

@@ -3114,7 +3114,7 @@ class Typer extends Namer
    */
   protected def matchingApply(methType: MethodOrPoly, pt: FunProto)(implicit ctx: Context): Boolean =
     methType.isContextual == pt.isContextual ||
-    methType.isImplicit && pt.isContextual // for a transition allow `with` arguments for regular implicit parameters
+    methType.isImplicitMethod && pt.isContextual // for a transition allow `with` arguments for regular implicit parameters
 
   /** Check that `tree == x: pt` is typeable. Used when checking a pattern
    *  against a selector of type `pt`. This implementation accounts for