Address review comments

Author: jchyb

Diff for: compiler/src/dotty/tools/dotc/inlines/InlineReducer.scala

@@ -198,7 +198,7 @@ class InlineReducer(inliner: Inliner)(using Context):
         val evTyper = new Typer(ctx.nestingLevel + 1)
         val evCtx = ctx.fresh.setTyper(evTyper)
         inContext(evCtx) {
-          val evidence = evTyper.inferImplicitArg(tpt.tpe, tpt.span, ignored = Set.empty)
+          val evidence = evTyper.inferImplicitArg(tpt.tpe, tpt.span)
           evidence.tpe match {
             case fail: Implicits.AmbiguousImplicits =>
               report.error(evTyper.missingArgMsg(evidence, tpt.tpe, ""), tpt.srcPos)

Diff for: compiler/src/dotty/tools/dotc/inlines/Inlines.scala

@@ -506,7 +506,7 @@ object Inlines:
           val evTyper = new Typer(ctx.nestingLevel + 1)
           val evCtx = ctx.fresh.setTyper(evTyper)
           inContext(evCtx) {
-            val evidence = evTyper.inferImplicitArg(tpe, callTypeArgs.head.span, ignored = Set.empty)
+            val evidence = evTyper.inferImplicitArg(tpe, callTypeArgs.head.span)
             evidence.tpe match
               case fail: Implicits.SearchFailureType =>
                 errorTree(call, evTyper.missingArgMsg(evidence, tpe, ""))

Diff for: compiler/src/dotty/tools/dotc/staging/HealType.scala

@@ -86,7 +86,7 @@ class HealType(pos: SrcPos)(using Context) extends TypeMap {
    */
   protected def tryHeal(tp: TypeRef): Type = {
     val reqType = defn.QuotedTypeClass.typeRef.appliedTo(tp)
-    val tag = ctx.typer.inferImplicitArg(reqType, pos.span, ignored = Set.empty)
+    val tag = ctx.typer.inferImplicitArg(reqType, pos.span)
     tag.tpe match
       case tp: TermRef =>
         ctx.typer.checkStable(tp, pos, "type witness")

Diff for: compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -901,7 +901,7 @@ trait Implicits:
         }
 
       try
-        val inferred = inferImplicit(adjust(to), from, from.span, ignored = Set.empty)
+        val inferred = inferImplicit(adjust(to), from, from.span)
 
         inferred match {
           case SearchSuccess(_, ref, _, false) if isOldStyleFunctionConversion(ref.underlying) =>
@@ -928,7 +928,7 @@ trait Implicits:
   /** Find an implicit argument for parameter `formal`.
    *  Return a failure as a SearchFailureType in the type of the returned tree.
    */
-  def inferImplicitArg(formal: Type, span: Span, ignored: Set[Symbol])(using Context): Tree =
+  def inferImplicitArg(formal: Type, span: Span, ignored: Set[Symbol] = Set.empty)(using Context): Tree =
     inferImplicit(formal, EmptyTree, span, ignored) match
       case SearchSuccess(arg, _, _, _) => arg
       case fail @ SearchFailure(failed) =>
@@ -944,7 +944,7 @@ trait Implicits:
 
   /** Search an implicit argument and report error if not found */
   def implicitArgTree(formal: Type, span: Span, where: => String = "")(using Context): Tree = {
-    val arg = inferImplicitArg(formal, span, ignored = Set.empty)
+    val arg = inferImplicitArg(formal, span)
     if (arg.tpe.isInstanceOf[SearchFailureType])
       report.error(missingArgMsg(arg, formal, where), ctx.source.atSpan(span))
     arg
@@ -968,7 +968,7 @@ trait Implicits:
     def ignoredInstanceNormalImport = arg.tpe match
       case fail: SearchFailureType =>
         if (fail.expectedType eq pt) || isFullyDefined(fail.expectedType, ForceDegree.none) then
-          inferImplicit(fail.expectedType, fail.argument, arg.span, Set.empty)(
+          inferImplicit(fail.expectedType, fail.argument, arg.span)(
             using findHiddenImplicitsCtx(ctx)) match {
             case s: SearchSuccess => Some(s)
             case f: SearchFailure =>
@@ -1082,7 +1082,7 @@ trait Implicits:
    *                         it should be applied, EmptyTree otherwise.
    *  @param span            The position where errors should be reported.
    */
-  def inferImplicit(pt: Type, argument: Tree, span: Span, ignored: Set[Symbol])(using Context): SearchResult = ctx.profiler.onImplicitSearch(pt):
+  def inferImplicit(pt: Type, argument: Tree, span: Span, ignored: Set[Symbol] = Set.empty)(using Context): SearchResult = ctx.profiler.onImplicitSearch(pt):
     trace(s"search implicit ${pt.show}, arg = ${argument.show}: ${argument.tpe.show}", implicits, show = true) {
       record("inferImplicit")
       assert(ctx.phase.allowsImplicitSearch,
@@ -1670,17 +1670,17 @@ trait Implicits:
         SearchFailure(TooUnspecific(pt), span)
       else
         val contextual = ctxImplicits != null
-        val prePreEligible = // the eligible candidates, ignoring positions
+        var preEligible = // the eligible candidates, ignoring positions
           if ctxImplicits != null then
             if ctx.gadt.isNarrowing then
               withoutMode(Mode.ImplicitsEnabled) {
                 ctxImplicits.uncachedEligible(wildProto)
               }
             else ctxImplicits.eligible(wildProto)
           else implicitScope(wildProto).eligible
-
-        val preEligible =
-          prePreEligible.filter(candidate => !ignored.contains(candidate.implicitRef.underlyingRef.symbol))
+        if !ignored.isEmpty then
+          preEligible =
+            preEligible.filter(candidate => !ignored.contains(candidate.implicitRef.underlyingRef.symbol))
         /** Does candidate `cand` come too late for it to be considered as an
          *  eligible candidate? This is the case if `cand` appears in the same
          *  scope as a given definition of the form `given ... = ...` that

Diff for: compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala

@@ -45,7 +45,7 @@ trait QuotesAndSplices {
         report.warning("Canceled splice directly inside a quote. '{ ${ XYZ } } is equivalent to XYZ.", tree.srcPos)
       case _ =>
     }
-    val quotes = inferImplicitArg(defn.QuotesClass.typeRef, tree.span, ignored = Set.empty)
+    val quotes = inferImplicitArg(defn.QuotesClass.typeRef, tree.span)
 
     if quotes.tpe.isInstanceOf[SearchFailureType] then
       report.error(missingArgMsg(quotes, defn.QuotesClass.typeRef, ""), ctx.source.atSpan(tree.span))

Diff for: compiler/src/dotty/tools/dotc/typer/Synthesizer.scala

@@ -45,7 +45,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
       case arg :: Nil =>
         instArg(arg) match
           case defn.ArrayOf(elemTp) =>
-            val etag = typer.inferImplicitArg(defn.ClassTagClass.typeRef.appliedTo(elemTp), span, Set.empty)
+            val etag = typer.inferImplicitArg(defn.ClassTagClass.typeRef.appliedTo(elemTp), span)
             if etag.tpe.isError then EmptyTree else etag.select(nme.wrap)
           case tp if hasStableErasure(tp) && !tp.isBottomTypeAfterErasure =>
             val sym = tp.typeSymbol
@@ -148,7 +148,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
 
     /** Is there an `CanEqual[T, T]` instance, assuming -strictEquality? */
     def hasEq(tp: Type)(using Context): Boolean =
-      val inst = typer.inferImplicitArg(defn.CanEqualClass.typeRef.appliedTo(tp, tp), span, ignored = Set.empty)
+      val inst = typer.inferImplicitArg(defn.CanEqualClass.typeRef.appliedTo(tp, tp), span)
       !inst.isEmpty && !inst.tpe.isError
 
     /** Can we assume the canEqualAny instance for `tp1`, `tp2`?

Diff for: compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1107,7 +1107,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           case Decimal => defn.FromDigits_DecimalClass
           case Floating => defn.FromDigits_FloatingClass
         }
-        inferImplicit(fromDigitsCls.typeRef.appliedTo(target), EmptyTree, tree.span, ignored = Set.empty) match {
+        inferImplicit(fromDigitsCls.typeRef.appliedTo(target), EmptyTree, tree.span) match {
           case SearchSuccess(arg, _, _, _) =>
             val fromDigits = untpd.Select(untpd.TypedSplice(arg), nme.fromDigits).withSpan(tree.span)
             val firstArg = Literal(Constant(digits))
@@ -1282,7 +1282,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     def withTag(tpe: Type): Option[Tree] = {
       require(ctx.mode.is(Mode.Pattern))
       withoutMode(Mode.Pattern)(
-        inferImplicit(tpe, EmptyTree, tree.tpt.span, ignored = Set.empty)
+        inferImplicit(tpe, EmptyTree, tree.tpt.span)
       ) match
         case SearchSuccess(clsTag, _, _, _) =>
           withMode(Mode.InTypeTest) {
@@ -4201,7 +4201,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
                 else formals1
               implicitArgs(formals2, argIndex + 1, pt)
 
-            val arg = inferImplicitArg(formal, tree.span.endPos, ignored = Set.empty)
+            val arg = inferImplicitArg(formal, tree.span.endPos)
             arg.tpe match
               case failed: AmbiguousImplicits =>
                 val pt1 = pt.deepenProtoTrans

Diff for: compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -2527,7 +2527,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
     object Implicits extends ImplicitsModule:
       def search(tpe: TypeRepr): ImplicitSearchResult =
         import tpd.TreeOps
-        val implicitTree = ctx.typer.inferImplicitArg(tpe, Position.ofMacroExpansion.span, ignored = Set.empty)
+        val implicitTree = ctx.typer.inferImplicitArg(tpe, Position.ofMacroExpansion.span)
         // Make sure that we do not have any uninstantiated type variables.
         // See tests/pos-macros/i16636.
         // See tests/pos-macros/exprSummonWithTypeVar with -Xcheck-macros.

Diff for: tests/run-macros/summonIgnoring-nonrecursive/Macro_1.scala

@@ -47,4 +47,4 @@ object TC2 {
       println(s"TC2[_] generated in macro using:")
       tc.print()
   }
-}
+}

Diff for: tests/run-macros/summonIgnoring-nonrecursive/Test_2.scala

@@ -3,4 +3,4 @@
 @main def Test(): Unit = {
   class C2
   summon[TC[C2]].print()
-}
+}

Diff for: tests/run-macros/summonIgnoring/Test_2.scala

@@ -12,4 +12,4 @@
     }
     summon[TC[C2]].print()
   }
-}
+}