Fix Applications#compare#isAsGood#isGiven to use parameter

Fix #21212

Author: EugeneFlesselle

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

@@ -1822,7 +1822,7 @@ trait Applications extends Compatibility {
           }
         case _ => // (3)
           def isGiven(alt: TermRef) =
-            alt1.symbol.is(Given) && alt.symbol != defn.NotGivenClass
+            alt.symbol.is(Given) && alt.symbol != defn.NotGivenClass
           def compareValues(tp1: Type, tp2: Type)(using Context) =
             isAsGoodValueType(tp1, tp2, isGiven(alt1), isGiven(alt2))
           tp2 match
@@ -1842,7 +1842,7 @@ trait Applications extends Compatibility {
      *     available in 3.0-migration if mode `Mode.OldImplicitResolution` is turned on as well.
      *     It is used to highlight differences between Scala 2 and 3 behavior.
      *
-     *   - In Scala 3.0-3.5, the behavior is as follows: `T <:p U` iff there is an impliit conversion
+     *   - In Scala 3.0-3.5, the behavior is as follows: `T <:p U` iff there is an implicit conversion
      *     from `T` to `U`, or
      *
      *        flip(T) <: flip(U)

tests/pos/i13044.scala

@@ -1,4 +1,4 @@
-//> using options -Xmax-inlines:33
+//> using options -Xmax-inlines:35
 
 import scala.deriving.Mirror
 import scala.compiletime._

tests/pos/i21212.scala

@@ -0,0 +1,33 @@
+
+trait Functor[F[_]]:
+  def map[A, B](fa: F[A])(f: A => B): F[B] = ???
+trait Monad[F[_]] extends Functor[F]
+trait MonadError[F[_], E] extends Monad[F]:
+  def raiseError[A](e: E): F[A]
+trait Temporal[F[_]] extends MonadError[F, Throwable]
+
+trait FunctorOps[F[_], A]:
+  def map[B](f: A => B): F[B] = ???
+implicit def toFunctorOps[F[_], A](target: F[A])(implicit tc: Functor[F]): FunctorOps[F, A] = ???
+
+class ContextBounds[F[_]: Temporal](using err: MonadError[F, Throwable]):
+  def useCase = err.raiseError(new RuntimeException())
+  val bool: F[Boolean] = ???
+  def fails = toFunctorOps(bool).map(_ => ())  // warns under -source:3.5, // error under -source:3.6
+
+class UsingArguments[F[_]](using Temporal[F])(using err: MonadError[F, Throwable]):
+  def useCase = err.raiseError(new RuntimeException())
+  val bool: F[Boolean] = ???
+  def works = toFunctorOps(bool).map(_ => ()) // warns under -source:3.5
+
+
+object Minimization:
+
+  trait A
+  trait B extends A
+
+  def test1(using a1: A)(using    b1: B) = summon[A] // picks (most general) a1
+  def test2(using a2: A)(implicit b2: B) = summon[A] // picks (most general) a2, was ambiguous
+  def test3(implicit       a3: A, b3: B) = summon[A] // picks (most specific) b3
+
+end Minimization