Don't use FullyDefinedType when synthesizing ClassTags

It's not necessary to instantiate all type variables, deeply, since
we are only interested in the outermost shape. Also, that way we do
not instantiate to Nothing, which is something difficult to recover from.

Author: odersky

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

@@ -444,7 +444,9 @@ object Inferencing {
   }
 
   /** The instantiation decision for given poly param computed from the constraint. */
-  enum Decision { case Min; case Max; case ToMax; case Skip; case Fail }
+  enum Decision:
+    case Min, Max, ToMax, Skip, Fail
+
   private def instDecision(tvar: TypeVar, v: Int, minimizeSelected: Boolean, ifBottom: IfBottom)(using Context): Decision =
     import Decision.*
     val direction = instDirection(tvar.origin)

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

@@ -29,17 +29,21 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
   private type SpecialHandlers = List[(ClassSymbol, SpecialHandler)]
 
   val synthesizedClassTag: SpecialHandler = (formal, span) =>
-    def instArg(tp: Type): Type = tp.stripTypeVar match
+    def instArg(tp: Type): Type = tp.dealias match
       // Special case to avoid instantiating `Int & S` to `Int & Nothing` in
       // i16328.scala. The intersection comes from an earlier instantiation
       // to an upper bound.
       // The dual situation with unions is harder to trigger because lower
       // bounds are usually widened during instantiation.
       case tp: AndOrType if tp.tp1 =:= tp.tp2 =>
         instArg(tp.tp1)
+      case tvar: TypeVar if ctx.typerState.constraint.contains(tvar) =>
+        instArg(
+            if tvar.hasLowerBound then tvar.instantiate(fromBelow = true)
+            else if tvar.hasUpperBound then tvar.instantiate(fromBelow = false)
+            else NoType)
       case _ =>
-        if isFullyDefined(tp, ForceDegree.all) then tp
-        else NoType // this happens in tests/neg/i15372.scala
+        tp
 
     val tag = formal.argInfos match
       case arg :: Nil =>