Special-case ClassTag argument instantiation to avoid failure

The previous commit ensures that `ClassTag[Int & Nothing]` doesn't compile
anymore so this isn't a soundness issue anymore, but since intersections can
arise out of type inference, it's worth adding a special-case here for
convenience. In particular, this fixes
#16328 (comment)

Author: smarter

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

@@ -28,9 +28,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
+      // 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 _ =>
+        if isFullyDefined(tp, ForceDegree.all) then tp
+        else NoType // this happens in tests/neg/i15372.scala
+
     val tag = formal.argInfos match
-      case arg :: Nil if isFullyDefined(arg, ForceDegree.all) =>
-        arg match
+      case arg :: Nil =>
+        instArg(arg) match
           case defn.ArrayOf(elemTp) =>
             val etag = typer.inferImplicitArg(defn.ClassTagClass.typeRef.appliedTo(elemTp), span)
             if etag.tpe.isError then EmptyTree else etag.select(nme.wrap)

tests/pos/i16328.scala

@@ -0,0 +1,19 @@
+import scala.reflect.ClassTag
+
+object Test {
+  def getParamType[T: ClassTag](x: T => Int): T = ???
+
+  def id[S](x: S): S = x
+
+  def main(args: Array[String]) = {
+    // worked before
+    val a1 = getParamType((x: Int) => x)
+    val a2: Int = a1 // ensure that we actually got a ClassTag for the right type
+
+    // broken before
+    val b1 = id(getParamType((x: Int) => x)) // was error
+    val b2: Int = b1
+    val c1 = id(id(getParamType((x: Int) => x))) // was error
+    val c2: Int = c1
+  }
+}