Refine rules when context bound evidence is tracked

Exclude synthetic, unnamed context bound evidence parameters.

Author: odersky

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

@@ -1862,18 +1862,20 @@ class Namer { typer: Typer =>
     sym.setParamss(paramSymss)
 
     /** Set every context bound evidence parameter of a class to be tracked,
-     *  provided it has a type that has an abstract type member. Reset private
-     *  and local flags so that the parameter becomes a `val`. Do the same for all
-     *  context bound evidence parameters of a `given` class. This is because
-     *  in Desugar.addParamRefinements we create refinements for these parameters
-     *  in the result type of the implicit access method.
+     *  provided it has a type that has an abstract type member and the parameter's
+     *  name is not a synthetic, unaddressable name. Reset private and local flags
+     *  so that the parameter becomes a `val`. Do the same for all context bound
+     *  evidence parameters of a `given` class. This is because in Desugar.addParamRefinements
+     *  we create refinements for these parameters in the result type of the implicit
+     *  access method.
      */
     def setTracked(param: ValDef): Unit =
       val sym = symbolOfTree(param)
       sym.maybeOwner.maybeOwner.infoOrCompleter match
         case info: TempClassInfo =>
           if !sym.is(Tracked)
               && param.hasAttachment(ContextBoundParam)
+              && !param.name.is(ContextBoundParamName)
               && (sym.info.memberNames(abstractTypeNameFilter).nonEmpty
                   || sym.maybeOwner.maybeOwner.is(Given))
           then

tests/pos/parsercombinators-new-syntax.scala

@@ -3,7 +3,6 @@ import collection.mutable
 
 /// A parser combinator.
 trait Combinator:
-
   type Self
   type Input
   type Result
@@ -13,21 +12,22 @@ trait Combinator:
     def parse(in: Input): Option[Result]
 end Combinator
 
-case class Apply[C, E](action: C => Option[E])
+case class Apply[I, R](action: I => Option[R])
 case class Combine[A, B](first: A, second: B)
 
 given [I, R] => Apply[I, R] is Combinator:
   type Input = I
   type Result = R
-  extension (self: Self)
+  extension (self: Apply[I, R])
     def parse(in: I): Option[R] = self.action(in)
 
 given [A: Combinator, B: Combinator { type Input = A.Input }]
     => Combine[A, B] is Combinator:
   type Input = A.Input
   type Result = (A.Result, B.Result)
-  extension (self: Self)
-    def parse(in: Input): Option[Result] = ???
+  extension (self: Combine[A, B])
+    def parse(in: Input): Option[Result] =
+      for x <- self.first.parse(in); y <- self.second.parse(in) yield (x, y)
 
 extension [A] (buf: mutable.ListBuffer[A]) def popFirst() =
   if buf.isEmpty then None