[FIR] Don't build placeholder projection for types

compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt

@@ -1782,8 +1782,9 @@ open class RawFirBuilder(
                     source = projectionSource
                 }
             }
+            val argumentList = typeProjection.parent as? KtTypeArgumentList
             val typeReference = typeProjection.typeReference
-            if (typeReference?.isPlaceholder == true) {
+            if (argumentList?.parent is KtCallExpression && typeReference?.isPlaceholder == true) {
                 return buildPlaceholderProjection {
                     source = projectionSource
                 }

compiler/testData/diagnostics/tests/inference/annotatedUnderscoredTypeArgument.fir.kt

@@ -0,0 +1,32 @@
+// !LANGUAGE: +PartiallySpecifiedTypeArguments
+// !DIAGNOSTICS: -UNCHECKED_CAST
+// WITH_RUNTIME
+
+fun <K, T> foo(x: (K) -> T): Pair<K, T> = (1 as K) to (1f as T)
+
+@Repeatable
+@Target(AnnotationTarget.TYPE)
+annotation class Anno
+
+@Repeatable
+@Target(AnnotationTarget.TYPE)
+annotation class Anno2
+
+@Repeatable
+@Target(AnnotationTarget.TYPE)
+annotation class Anno3(val x: String)
+
+fun box(): String {
+    val x = foo<@Anno Int, <!UNSUPPORTED("annotations on an underscored type argument")!>@Anno<!> _> { it.toFloat() }
+    val y: Pair<Int, Float> = foo<@[<!UNSUPPORTED!>Anno<!> <!UNSUPPORTED!>Anno2<!>] _, <!UNSUPPORTED!>@Anno<!> _> { it.toFloat() }
+    val z1: Pair<Int, Float> = foo<<!UNSUPPORTED!>@Anno<!> <!UNSUPPORTED!>@Anno2<!> /**/ _, @[/**/ <!UNSUPPORTED!>Anno<!>    /**/ ] _> { it.toFloat() }
+    val z2: Pair<Int, Float> = foo<<!UNSUPPORTED!>@Anno3("")<!> /**/ _, @[/**/ <!UNSUPPORTED!>Anno<!>    /**/ <!UNSUPPORTED!>Anno3("")<!> /**/] _,> { it.toFloat() }
+
+    val z31: Pair<<!UNRESOLVED_REFERENCE!>@Anno3("") _<!>, Float> = 1 to 1f
+    val z32: Pair<<!UNRESOLVED_REFERENCE!>_<!>, Float> = 1 to 1f
+    val z33: Pair<<!UNRESOLVED_REFERENCE!>@Anno3("") (_)<!>, Float> = 1 to 1f
+    val z34: Pair<<!UNRESOLVED_REFERENCE!>((_))<!>, Float> = 1 to 1f
+    val z35: Pair<<!UNRESOLVED_REFERENCE!>(@Anno3("") (_))<!>, Float> = 1 to 1f
+
+    return "OK"
+}

compiler/testData/diagnostics/tests/inference/annotatedUnderscoredTypeArgument.kt

@@ -1,6 +1,5 @@
 // !LANGUAGE: +PartiallySpecifiedTypeArguments
 // !DIAGNOSTICS: -UNCHECKED_CAST
-// FIR_IDENTICAL
 // WITH_RUNTIME
 
 fun <K, T> foo(x: (K) -> T): Pair<K, T> = (1 as K) to (1f as T)
@@ -23,6 +22,11 @@ fun box(): String {
     val z1: Pair<Int, Float> = foo<<!UNSUPPORTED!>@Anno<!> <!UNSUPPORTED!>@Anno2<!> /**/ _, @[/**/ <!UNSUPPORTED!>Anno<!>    /**/ ] _> { it.toFloat() }
     val z2: Pair<Int, Float> = foo<<!UNSUPPORTED!>@Anno3("")<!> /**/ _, @[/**/ <!UNSUPPORTED!>Anno<!>    /**/ <!UNSUPPORTED!>Anno3("")<!> /**/] _,> { it.toFloat() }
 
-    val z3: Pair<@Anno3("") <!UNRESOLVED_REFERENCE!>_<!>, Float> = 1 to 1f
+    val z31: Pair<@Anno3("") <!UNRESOLVED_REFERENCE!>_<!>, Float> = 1 to 1f
+    val z32: Pair<<!UNRESOLVED_REFERENCE!>_<!>, Float> = 1 to 1f
+    val z33: Pair<@Anno3("") (<!UNRESOLVED_REFERENCE!>_<!>), Float> = 1 to 1f
+    val z34: Pair<((<!UNRESOLVED_REFERENCE!>_<!>)), Float> = 1 to 1f
+    val z35: Pair<(@Anno3("") (<!UNRESOLVED_REFERENCE!>_<!>)), Float> = 1 to 1f
+
     return "OK"
 }

compiler/testData/diagnostics/tests/inference/illegalUnderscoredTypeArgument.fir.kt

@@ -5,6 +5,6 @@ fun <K, T> foo(x: (K) -> T): Pair<K, T> = TODO()
 class Foo<K>
 
 fun main() {
-    val x = foo<Int, Foo<_>> { it.toFloat() }
+    val x = foo<Int, Foo<<!UNRESOLVED_REFERENCE!>_<!>>> { <!ARGUMENT_TYPE_MISMATCH!>it.toFloat()<!> }
 
 }

compiler/testData/diagnostics/tests/inference/underscoredTypeArgument.fir.kt

@@ -0,0 +1,10 @@
+// FIR_IDENTICAL
+// !DIAGNOSTICS: -UNCHECKED_CAST
+// WITH_RUNTIME
+
+fun <K, T> foo(x: (K) -> T): Pair<K, T> = (1 as K) to (1f as T)
+
+fun box(): String {
+    val x = foo<Int, _> { it.toFloat() } // Pair<Int, Float>
+    return "OK"
+}

compiler/testData/diagnostics/tests/inference/underscoredTypeArgument.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNCHECKED_CAST
 // WITH_RUNTIME