Discourage default arg for extension receiver

Author: som-snytt

Diff for: compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala

@@ -221,6 +221,7 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe
   case GivenSearchPriorityID // errorNumber: 205
   case EnumMayNotBeValueClassesID // errorNumber: 206
   case IllegalUnrollPlacementID // errorNumber: 207
+  case ExtensionHasDefaultID // errorNumber: 208
 
   def errorNumber = ordinal - 1
 

Diff for: compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -2514,6 +2514,15 @@ class ExtensionNullifiedByMember(method: Symbol, target: Symbol)(using Context)
        |
        |The extension may be invoked as though selected from an arbitrary type if conversions are in play."""
 
+class ExtensionHasDefault(method: Symbol)(using Context)
+  extends Message(ExtensionHasDefaultID):
+  def kind = MessageKind.PotentialIssue
+  def msg(using Context) =
+    i"""Extension method ${hl(method.name.toString)} should not have a default argument for its receiver."""
+  def explain(using Context) =
+    i"""Although extensions are ordinary methods, they must be invoked as a selection.
+       |Therefore, the receiver cannot be omitted. A default argument for that parameter would never be used."""
+
 class TraitCompanionWithMutableStatic()(using Context)
   extends SyntaxMsg(TraitCompanionWithMutableStaticID) {
   def msg(using Context) = i"Companion of traits cannot define mutable @static fields"

Diff for: compiler/src/dotty/tools/dotc/typer/RefChecks.scala

@@ -1163,22 +1163,20 @@ object RefChecks {
    *  that are either both opaque types or both not.
    */
   def checkExtensionMethods(sym: Symbol)(using Context): Unit =
-    if sym.is(Extension) && !sym.nextOverriddenSymbol.exists then
+    if sym.is(Extension) then
       extension (tp: Type)
-        def strippedResultType = Applications.stripImplicit(tp.stripPoly, wildcardOnly = true).resultType
-        def firstExplicitParamTypes = Applications.stripImplicit(tp.stripPoly, wildcardOnly = true).firstParamTypes
+        def explicit = Applications.stripImplicit(tp.stripPoly, wildcardOnly = true)
         def hasImplicitParams = tp.stripPoly match { case mt: MethodType => mt.isImplicitMethod case _ => false }
-      val target = sym.info.firstExplicitParamTypes.head // required for extension method, the putative receiver
-      val methTp = sym.info.strippedResultType // skip leading implicits and the "receiver" parameter
+      val target = sym.info.explicit.firstParamTypes.head // required for extension method, the putative receiver
+      val methTp = sym.info.explicit.resultType // skip leading implicits and the "receiver" parameter
       def hidden =
         target.nonPrivateMember(sym.name)
-        .filterWithPredicate:
-          member =>
+        .filterWithPredicate: member =>
           member.symbol.isPublic && {
             val memberIsImplicit = member.info.hasImplicitParams
             val paramTps =
               if memberIsImplicit then methTp.stripPoly.firstParamTypes
-              else methTp.firstExplicitParamTypes
+              else methTp.explicit.firstParamTypes
 
             paramTps.isEmpty || memberIsImplicit && !methTp.hasImplicitParams || {
               val memberParamTps = member.info.stripPoly.firstParamTypes
@@ -1190,7 +1188,13 @@ object RefChecks {
             }
           }
         .exists
-      if !target.typeSymbol.isOpaqueAlias && hidden
+      val receiverName = sym.info.explicit.firstParamNames.head
+      val num = sym.info.paramNamess.flatten.indexWhere(_ == receiverName)
+      val getterName = DefaultGetterName(sym.name.toTermName, num = num)
+      val getterDenot = sym.owner.info.member(getterName)
+      if getterDenot.exists
+      then report.warning(ExtensionHasDefault(sym), getterDenot.symbol.srcPos)
+      if !target.typeSymbol.isOpaqueAlias && !sym.nextOverriddenSymbol.exists && hidden
       then report.warning(ExtensionNullifiedByMember(sym, target.typeSymbol), sym.srcPos)
   end checkExtensionMethods
 

Diff for: tests/warn/i12460.check

@@ -0,0 +1,20 @@
+-- [E208] Potential Issue Warning: tests/warn/i12460.scala:3:23 --------------------------------------------------------
+3 |extension (s: String = "hello, world") def invert = s.reverse.toUpperCase // warn
+  |                       ^
+  |                       Extension method invert must not have a default argument for its receiver.
+  |---------------------------------------------------------------------------------------------------------------------
+  | Explanation (enabled by `-explain`)
+  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  | Although extensions are ordinary methods, they must be invoked as a selection.
+  | Therefore, the receiver cannot be omitted. A default argument for that parameter would never be used.
+   ---------------------------------------------------------------------------------------------------------------------
+-- [E208] Potential Issue Warning: tests/warn/i12460.scala:5:17 --------------------------------------------------------
+5 |extension (using String)(s: String = "hello, world") def revert = s.reverse.toUpperCase // warn
+  |                 ^
+  |                 Extension method revert must not have a default argument for its receiver.
+  |---------------------------------------------------------------------------------------------------------------------
+  | Explanation (enabled by `-explain`)
+  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  | Although extensions are ordinary methods, they must be invoked as a selection.
+  | Therefore, the receiver cannot be omitted. A default argument for that parameter would never be used.
+   ---------------------------------------------------------------------------------------------------------------------

Diff for: tests/warn/i12460.scala

@@ -0,0 +1,7 @@
+//> using options -explain
+
+extension (s: String = "hello, world") def invert = s.reverse.toUpperCase // warn
+
+extension (using String)(s: String = "hello, world") def revert = s.reverse.toUpperCase // warn
+
+extension (s: String) def divert(m: String  = "hello, world") = (s+m).reverse.toUpperCase // ok