Defend against AliasingBounds

In refchecks for extension methods, obtain a TypeRef
of the receiver parameter type, so that it is correctly
dealiased. The prior idiom produced a TypeAlias.

Author: som-snytt

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

@@ -1158,16 +1158,11 @@ object RefChecks {
    */
   def checkExtensionMethods(sym: Symbol)(using Context): Unit =
     if sym.is(Extension) then atPhase(typerPhase):
-      extension (tp: Type)
-        def explicit = Applications.stripImplicit(tp.stripPoly, wildcardOnly = true)
-        def hasImplicitParams = tp.stripPoly match { case mt: MethodType => mt.isImplicitMethod case _ => false }
-        def isParamLess = tp.stripPoly match { case mt: MethodType => false case _ => true }
+      extension (tp: Type) def explicit = Applications.stripImplicit(tp.widen, wildcardOnly = false)
       val explicitInfo = sym.info.explicit // consider explicit value params
       def memberHidesMethod(member: Denotation): Boolean =
-        val methTp = explicitInfo.resultType // skip leading implicits and the "receiver" parameter
-        if methTp.isParamLess then
-          return true // extension without parens is always hidden by a member of same name
-        val memberIsImplicit = member.info.hasImplicitParams
+        val methTp = explicitInfo.stripPoly.resultType // skip leading implicits and the "receiver" parameter
+        val memberIsImplicit = member.info.isImplicitMethod
         inline def paramsCorrespond =
           val paramTps =
             if memberIsImplicit then methTp.stripPoly.firstParamTypes
@@ -1176,11 +1171,13 @@ object RefChecks {
           memberParamTps.corresponds(paramTps): (m, x) =>
                m.typeSymbol.denot.isOpaqueAlias == x.typeSymbol.denot.isOpaqueAlias
             && (x frozen_<:< m)
-        memberIsImplicit && !methTp.hasImplicitParams || paramsCorrespond
+
+           methTp.isParameterless // extension without parens is always hidden by a member of same name
+        || memberIsImplicit && !methTp.isImplicitMethod // see above
+        || paramsCorrespond // match by type and opacity
       def targetOfHiddenExtension: Symbol =
-        val target =
-          val target0 = explicitInfo.firstParamTypes.head // required for extension method, the putative receiver
-          target0.dealiasKeepOpaques.typeSymbol.info
+        val target = explicitInfo.firstParamTypes.head // required for extension method; the nominal receiver
+          .typeSymbol.typeRef.dealiasKeepOpaques
         val member = target.nonPrivateMember(sym.name)
           .filterWithPredicate: member =>
             member.symbol.isPublic && memberHidesMethod(member)

tests/warn/i23666.scala

@@ -0,0 +1,15 @@
+
+type Tuple = scala.Tuple
+
+infix type =:= [A, B] = A => B
+
+object `=:=` :
+   given [A] => A =:= A = a => a
+
+extension [T <: Tuple] (tuple: T)
+
+   def reverse[A, B](using ev: T =:= (A, B)): (B, A) = // warn
+      val ab = ev(tuple)
+      (ab._2, ab._1)
+
+   def toList: List[Nothing] = Nil // warn