Refine isMatched of IgnoredProtos

Fixes the Open CB counter example.

Author: odersky

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

@@ -162,13 +162,15 @@ object ProtoTypes {
     override def viewExists(tp: Type, pt: Type)(using Context): Boolean = false
   }
 
-  /** A trait for prototypes that match all types */
-  trait MatchAlways extends ProtoType {
-    def isMatchedBy(tp1: Type, keepConstraint: Boolean)(using Context): Boolean = true
+  /** A trait for prototypes that map to themselves */
+  trait FixedProto extends ProtoType:
     def map(tm: TypeMap)(using Context): ProtoType = this
     def fold[T](x: T, ta: TypeAccumulator[T])(using Context): T = x
     override def toString: String = getClass.toString
-  }
+
+  /** A trait for prototypes that match all types */
+  trait MatchAlways extends FixedProto:
+    def isMatchedBy(tp1: Type, keepConstraint: Boolean)(using Context): Boolean = true
 
   /** A class marking ignored prototypes that can be revealed by `deepenProto` */
   abstract case class IgnoredProto(ignored: Type) extends CachedGroundType with MatchAlways:
@@ -179,6 +181,19 @@ object ProtoTypes {
       ignored
     override def deepenProtoTrans(using Context): Type = ignored.deepenProtoTrans
 
+    override def isMatchedBy(tp1: Type, keepConstraint: Boolean)(using Context): Boolean =
+      ignored match
+        case ignored: SelectionProto if ignored.name != nme.apply =>
+          // Non-implicit methods don't match ignored selection protos unless the
+          // selection is via `apply`. This is because a match of a different selection
+          // would require an eta expansion _and_ and an implicit conversion, which is
+          // not allowed. So the prototype would not match even if implicit conversions
+          // were present. Test case: i23773a.scala
+          tp1.widen match
+            case tp1w: MethodOrPoly => tp1w.isImplicitMethod
+            case _ => true
+        case _ => true
+
     /** Did someone look inside via deepenProto? Used for error deagniostics
      *  to give a more extensive expected type.
      */

tests/pos/i23773a.scala

@@ -0,0 +1,19 @@
+trait NumericDate
+trait JWSDecoded[H]
+
+trait StandardHeaderWrite[H]:
+  def setAlgorithm(header: H, algorithm: Algorithm): H
+
+object StandardHeaderWrite:
+  def apply[H](using sh: StandardHeaderWrite[H]): StandardHeaderWrite[H] = ???
+  // unused - required to reproduce
+  def apply[H](setAlg: (H, Algorithm) => H): StandardHeaderWrite[H] = ???
+
+final case class JWK(algorithm: Option[Algorithm])
+sealed trait Algorithm
+
+def Test[F[_], H](key: JWK, header: H)(using StandardHeaderWrite[H]) = {
+  key.algorithm
+    .map(StandardHeaderWrite[H].setAlgorithm(header, _))
+    .getOrElse(header)
+}