Also exclude when param is alias type

Author: som-snytt

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

@@ -1148,6 +1148,9 @@ object RefChecks {
         def strippedResultType = Applications.stripImplicit(tp.stripPoly, wildcardOnly = true).resultType
         def firstExplicitParamTypes = Applications.stripImplicit(tp.stripPoly, wildcardOnly = true).firstParamTypes
         def hasImplicitParams = tp.stripPoly match { case mt: MethodType => mt.isImplicitMethod case _ => false }
+        def isAnyAlias =
+          val denot = tp.typeSymbol.denot
+          denot.isAliasType || denot.isOpaqueAlias
       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
       def hidden =
@@ -1159,14 +1162,14 @@ object RefChecks {
             if memberIsImplicit then methTp.stripPoly.firstParamTypes
             else methTp.firstExplicitParamTypes
 
-          paramTps.isEmpty || memberIsImplicit && !methTp.hasImplicitParams || {
+          paramTps.isEmpty || memberIsImplicit && !methTp.hasImplicitParams || !paramTps.exists(_.typeSymbol.denot.isOpaqueAlias) && {
             val memberParamTps = member.info.stripPoly.firstParamTypes
             !memberParamTps.isEmpty
             && memberParamTps.lengthCompare(paramTps) == 0
             && memberParamTps.lazyZip(paramTps).forall((m, x) => x frozen_<:< m)
           }
         .exists
-      if !target.typeSymbol.denot.isAliasType && !target.typeSymbol.denot.isOpaqueAlias && hidden
+      if !target.isAnyAlias && hidden
       then report.warning(ExtensionNullifiedByMember(sym, target.typeSymbol), sym.srcPos)
   end checkExtensionMethods
 

tests/warn/opaque-overwarn.scala

@@ -0,0 +1,24 @@
+
+package reproduction.opaqueoverwarning
+
+opaque type FromEnd = Int
+object FromEnd:
+  inline def apply(i: Int): FromEnd = i
+  extension (fe: FromEnd)
+    inline def value: Int = fe
+
+// Warning appears when extension is in same namespace as opaque type
+// under 3.5.0-RC3 (and 3.6.0 nightly)
+extension [A](a: Array[A])
+  inline def apply(fe: FromEnd): A =
+    a(a.length - 1 - FromEnd.value(fe))
+
+object Main:
+  def run(): Unit =
+    val xs = Array(1, 2, 3)
+
+    println(s"First element = ${xs(0)}")
+    println(s"Last element = ${xs(FromEnd(0))}")
+
+  def main(args: Array[String]): Unit =
+    run()