Fix #7249: Search for hidden givens only at whole type

Don't try to find a hidden implicit for a part of type type that
was searched for, unless that part is fully defined.

The reason is that any type variables in a subtype might be associated
with constraints that are lost at the point of issuing a the hidden
givens addendum.

The commit also contains a tweak to "isFullyDefined" which makes
an uninstantiated type variable that is not bound in the current
constraint count as "not fully defined", where previously it was
"fully defined".

Author: odersky

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

@@ -25,7 +25,7 @@ import Constants._
 import ProtoTypes._
 import ErrorReporting._
 import reporting.diagnostic.Message
-import Inferencing.fullyDefinedType
+import Inferencing.{fullyDefinedType, isFullyDefined}
 import Trees._
 import transform.SymUtils._
 import transform.TypeUtils._
@@ -392,7 +392,8 @@ object Implicits {
     def whyNoConversion(implicit ctx: Context): String = ""
   }
 
-  class NoMatchingImplicits(val expectedType: Type, val argument: Tree, constraint: Constraint = OrderingConstraint.empty) extends SearchFailureType {
+  class NoMatchingImplicits(val expectedType: Type, val argument: Tree, constraint: Constraint = OrderingConstraint.empty)
+  extends SearchFailureType {
 
     /** Replace all type parameters in constraint by their bounds, to make it clearer
      *  what was expected
@@ -1215,15 +1216,21 @@ trait Implicits { self: Typer =>
               if (ctx == NoContext) ctx
               else ctx.freshOver(FindHiddenImplicitsCtx(ctx.outer)).addMode(Mode.FindHiddenImplicits)
 
-            inferImplicit(fail.expectedType, fail.argument, arg.span)(
-              FindHiddenImplicitsCtx(ctx)) match {
-              case s: SearchSuccess => hiddenImplicitNote(s)
-              case f: SearchFailure =>
-                f.reason match {
-                  case ambi: AmbiguousImplicits => hiddenImplicitNote(ambi.alt1)
-                  case r => ""
-                }
-            }
+            if (fail.expectedType eq pt) || isFullyDefined(fail.expectedType, ForceDegree.none) then
+              inferImplicit(fail.expectedType, fail.argument, arg.span)(
+                FindHiddenImplicitsCtx(ctx)) match {
+                case s: SearchSuccess => hiddenImplicitNote(s)
+                case f: SearchFailure =>
+                  f.reason match {
+                    case ambi: AmbiguousImplicits => hiddenImplicitNote(ambi.alt1)
+                    case r => ""
+                  }
+              }
+            else
+              // It's unsafe to search for parts of the expected type if they are not fully defined,
+              // since these come with nested contexts that are lost at this point. See #7249 for an
+              // example where searching for a nested type causes an infinite loop.
+              ""
         }
         msg(userDefined.getOrElse(
           em"no implicit argument of type $pt was found${location("for")}"))() ++

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

@@ -104,9 +104,10 @@ object Inferencing {
     def apply(x: Boolean, tp: Type): Boolean = tp.dealias match {
       case _: WildcardType | _: ProtoType =>
         false
-      case tvar: TypeVar
-      if !tvar.isInstantiated && ctx.typerState.constraint.contains(tvar) =>
-        force.appliesTo(tvar) && {
+      case tvar: TypeVar if !tvar.isInstantiated =>
+        force.appliesTo(tvar)
+        && ctx.typerState.constraint.contains(tvar)
+        && {
           val direction = instDirection(tvar.origin)
           def avoidBottom =
             !force.allowBottom &&

tests/neg/i7249.scala

@@ -0,0 +1,9 @@
+import Predef.{$conforms => _, _}
+
+trait F[H, T]
+
+
+object Test extends App {
+  given f[H, T](given h: H, t: T): F[H, T] = ???
+  summon[F[Int, Unit]]  // error
+}