ExtensionNullifiedByMember requires both opaque params

Author: som-snytt

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

@@ -1156,6 +1156,11 @@ object RefChecks {
    *
    *  If the extension method is nullary, it is always hidden by a member of the same name.
    *  (Either the member is nullary, or the reference is taken as the eta-expansion of the member.)
+   *
+   *  This check is in lieu of a more expensive use-site check that an application failed to use an extension.
+   *  That check would account for accessibility and opacity. As a limitation, this check considers
+   *  only public members, a target receiver that is not an alias, and corresponding method parameters
+   *  that are either both opaque types or both not.
    */
   def checkExtensionMethods(sym: Symbol)(using Context): Unit =
     if sym.is(Extension) && !sym.nextOverriddenSymbol.exists then
@@ -1179,7 +1184,9 @@ object RefChecks {
               val memberParamTps = member.info.stripPoly.firstParamTypes
               !memberParamTps.isEmpty
               && memberParamTps.lengthCompare(paramTps) == 0
-              && memberParamTps.lazyZip(paramTps).forall((m, x) => x frozen_<:< m)
+              && memberParamTps.lazyZip(paramTps).forall: (m, x) =>
+                m.typeSymbol.denot.isOpaqueAlias == x.typeSymbol.denot.isOpaqueAlias
+                && (x frozen_<:< m)
             }
           }
         .exists

tests/warn/i22279.scala

@@ -0,0 +1,24 @@
+
+import scala.io.Source
+
+object Lengths:
+  opaque type Length = Int
+  object Length:
+    def apply(i: Int): Length = i
+  extension (source: Source)
+    def take(length: Length): IndexedSeq[Char] = // no warn
+      source.take(length).to(IndexedSeq)
+end Lengths
+
+trait Taken:
+  def take(n: Lengths.Length): Taken = ???
+
+object Lengthy:
+  import Lengths.*
+  extension (taken: Taken) def take(n: Length): Taken = ??? // warn
+
+@main def test() = println:
+  import Lengths.*
+  val src = Source.fromString("hello, world")
+  val len = Length("hello".length)
+  src.take(len)