Unify Type.isImplicitMethod with MethodType.isImplicit

Author: nicolasstucki

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -451,7 +451,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
   def mayBeVarGetter(sym: Symbol)(implicit ctx: Context): Boolean = {
     def maybeGetterType(tpe: Type): Boolean = tpe match {
       case _: ExprType => true
-      case tpe: MethodType => tpe.isImplicit
+      case tpe: MethodType => tpe.isImplicitMethod
       case tpe: PolyType => maybeGetterType(tpe.resultType)
       case _ => false
     }

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

@@ -292,10 +292,7 @@ object Types {
     def isJavaMethod: Boolean = false
 
     /** Is this a MethodType which has implicit parameters */
-    final def isImplicitMethod: Boolean = this match {
-      case mt: MethodType => mt.isImplicit
-      case _ => false
-    }
+    def isImplicitMethod: Boolean = false
 
 // ----- Higher-order combinators -----------------------------------
 
@@ -1326,7 +1323,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.isJavaMethod)), mt.resultType, mt.isImplicit && !ctx.erasedTypes)
+          formals1 mapConserve (_.underlyingIfRepeated(mt.isJavaMethod)), mt.resultType, mt.isImplicitMethod && !ctx.erasedTypes)
     }
 
     /** The signature of this type. This is by default NotAMethod,
@@ -2706,7 +2703,7 @@ object Types {
     final def companion: MethodTypeCompanion = MethodType.withKind(kind)
 
     final override def isJavaMethod: Boolean = kind is JavaKind
-    final def isImplicit: Boolean = kind is ImplicitKind
+    final override def isImplicitMethod: Boolean = kind is ImplicitKind
 
     val paramInfos = paramInfosExp(this)
     val resType = resultTypeExp(this)

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -182,7 +182,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
       case tp: MethodType =>
         def paramText(name: TermName, tp: Type) = toText(name) ~ ": " ~ toText(tp)
         changePrec(GlobalPrec) {
-          (if (tp.isImplicit) "(implicit " else "(") ~
+          (if (tp.isImplicitMethod) "(implicit " else "(") ~
             Text((tp.paramNames, tp.paramInfos).zipped map paramText, ", ") ~
           (if (tp.resultType.isInstanceOf[MethodType]) ")" else "): ") ~
           toText(tp.resultType)

compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala

@@ -308,7 +308,7 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
         val params = (pnames, ptypes, defaults).zipped.map((pname, ptype, isDefault) =>
           new api.MethodParameter(pname.toString, apiType(ptype),
             isDefault, api.ParameterModifier.Plain))
-        new api.ParameterList(params.toArray, mt.isImplicit) :: paramLists(restpe, params.length)
+        new api.ParameterList(params.toArray, mt.isImplicitMethod) :: paramLists(restpe, params.length)
       case _ =>
         Nil
     }

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

@@ -1149,7 +1149,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
 
     /** Drop any implicit parameter section */
     def stripImplicit(tp: Type): Type = tp match {
-      case mt: MethodType if mt.isImplicit =>
+      case mt: MethodType if mt.isImplicitMethod =>
         resultTypeApprox(mt)
       case pt: PolyType =>
         pt.derivedLambdaType(pt.paramNames, pt.paramInfos, stripImplicit(pt.resultType))

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

@@ -145,7 +145,7 @@ object EtaExpansion {
       ids = ids.init :+ repeated(ids.last)
     var body: Tree = Apply(lifted, ids)
     mt.resultType match {
-      case rt: MethodType if !rt.isImplicit => body = PostfixOp(body, Ident(nme.WILDCARD))
+      case rt: MethodType if !rt.isImplicitMethod => body = PostfixOp(body, Ident(nme.WILDCARD))
       case _ =>
     }
     val fn = untpd.Function(params, body)

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

@@ -65,15 +65,15 @@ object Implicits {
 
         def discardForView(tpw: Type, argType: Type): Boolean = tpw match {
           case mt: MethodType =>
-            mt.isImplicit ||
+            mt.isImplicitMethod ||
             mt.paramInfos.length != 1 ||
             !ctx.typerState.test(argType relaxed_<:< mt.paramInfos.head)
           case poly: PolyType =>
             // We do not need to call ProtoTypes#constrained on `poly` because
             // `refMatches` is always called with mode TypevarsMissContext enabled.
             poly.resultType match {
               case mt: MethodType =>
-                mt.isImplicit ||
+                mt.isImplicitMethod ||
                 mt.paramInfos.length != 1 ||
                 !ctx.typerState.test(argType relaxed_<:< wildApprox(mt.paramInfos.head, null, Set.empty))
               case rtp =>
@@ -109,7 +109,7 @@ object Implicits {
         }
 
         def discardForValueType(tpw: Type): Boolean = tpw.stripPoly match {
-          case tpw: MethodType => !tpw.isImplicit
+          case tpw: MethodType => !tpw.isImplicitMethod
           case _ => false
         }
 

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

@@ -446,7 +446,7 @@ object ProtoTypes {
       case poly: PolyType =>
         normalize(constrained(poly).resultType, pt)
       case mt: MethodType =>
-        if (mt.isImplicit) normalize(resultTypeApprox(mt), pt)
+        if (mt.isImplicitMethod) normalize(resultTypeApprox(mt), pt)
         else if (mt.isDependent) tp
         else {
           val rt = normalize(mt.resultType, pt)

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

@@ -1992,7 +1992,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     def adaptNoArgs(wtp: Type): Tree = wtp match {
       case wtp: ExprType =>
         adaptInterpolated(tree.withType(wtp.resultType), pt)
-      case wtp: MethodType if wtp.isImplicit && constrainResult(wtp, followAlias(pt)) =>
+      case wtp: MethodType if wtp.isImplicitMethod && constrainResult(wtp, followAlias(pt)) =>
         val tvarsToInstantiate = tvarsInParams(tree)
         wtp.paramInfos.foreach(instantiateSelected(_, tvarsToInstantiate))
         val constr = ctx.typerState.constraint
@@ -2109,7 +2109,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
           typed(etaExpand(tree, wtp, arity), pt)
         else if (wtp.paramInfos.isEmpty && isAutoApplied(tree.symbol))
           adaptInterpolated(tpd.Apply(tree, Nil), pt)
-        else if (wtp.isImplicit)
+        else if (wtp.isImplicitMethod)
           err.typeMismatch(tree, pt)
         else
           missingArgs(wtp)