Minor. Report reified-related diagnostics on arguments if possible

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/ReifiedTypeParameterSubstitutionChecker.java

@@ -46,18 +46,22 @@ public class ReifiedTypeParameterSubstitutionChecker implements CallChecker {
                     !((TypeParameterDescriptor) argumentDeclarationDescription).isReified()
                 ) {
                     context.trace.report(
-                            Errors.TYPE_PARAMETER_AS_REIFIED.on(getCallElement(context), parameter)
+                            Errors.TYPE_PARAMETER_AS_REIFIED.on(getElementToReport(context, parameter.getIndex()), parameter)
                     );
                 }
                 else if (TypeUtilsKt.cannotBeReified(argument)) {
-                    context.trace.report(Errors.REIFIED_TYPE_FORBIDDEN_SUBSTITUTION.on(getCallElement(context), argument));
+                    context.trace.report(
+                            Errors.REIFIED_TYPE_FORBIDDEN_SUBSTITUTION.on(getElementToReport(context, parameter.getIndex()), argument));
                 }
             }
         }
     }
 
     @NotNull
-    private static PsiElement getCallElement(@NotNull BasicCallResolutionContext context) {
+    private static PsiElement getElementToReport(@NotNull BasicCallResolutionContext context, int parameterIndex) {
+        if (context.call.getTypeArguments().size() > parameterIndex) {
+            return context.call.getTypeArguments().get(parameterIndex);
+        }
         KtExpression callee = context.call.getCalleeExpression();
         return callee != null ? callee : context.call.getCallElement();
     }

compiler/testData/diagnostics/tests/generics/tpAsReified/InConstructor.kt

@@ -6,7 +6,7 @@ fun <A> main() {
     <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>C<!>()
 
     val <!UNUSED_VARIABLE!>a<!>: C<A> = <!TYPE_PARAMETER_AS_REIFIED!>C<!>()
-    <!TYPE_PARAMETER_AS_REIFIED!>C<!><A>()
+    C<<!TYPE_PARAMETER_AS_REIFIED!>A<!>>()
 
     val <!UNUSED_VARIABLE!>b<!>: C<Int> = C()
     C<Int>()

compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.kt

@@ -8,7 +8,7 @@ fun <A> main() {
     <!TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>f<!>()
 
     val <!UNUSED_VARIABLE!>a<!>: A = <!TYPE_PARAMETER_AS_REIFIED!>f<!>()
-    <!TYPE_PARAMETER_AS_REIFIED!>f<!><A>()
+    f<<!TYPE_PARAMETER_AS_REIFIED!>A<!>>()
 
     val <!UNUSED_VARIABLE!>b<!>: Int = f()
     f<Int>()

compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/reified.kt

@@ -4,9 +4,9 @@ fun <reified T> foo(t: T) {}
 class C<reified T>(t: T)
 
 fun test(d: dynamic) {
-    <!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>foo<!><dynamic>(d)
+    foo<<!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>dynamic<!>>(d)
     <!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>foo<!>(d)
 
-    <!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>C<!><dynamic>(d)
+    C<<!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>dynamic<!>>(d)
     <!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>C<!>(d)
 }

compiler/testData/diagnostics/testsWithStdLib/ArrayOfNothing.kt

@@ -38,8 +38,8 @@ fun test4(
 ) {}
 
 fun test5() {
-    <!UNSUPPORTED!><!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>arrayOf<!><Nothing>()<!>
-    <!UNSUPPORTED!><!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>Array<!><Nothing>(10) { throw Exception() }<!>
+    <!UNSUPPORTED!>arrayOf<<!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>Nothing<!>>()<!>
+    <!UNSUPPORTED!>Array<<!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>Nothing<!>>(10) { throw Exception() }<!>
 }
 
 fun <T> foo(): Array<T> = (object {} as Any) as Array<T>

compiler/testData/diagnostics/testsWithStdLib/reified/arrayConstruction.kt

@@ -4,7 +4,7 @@ fun <T> ok1(block: () -> Array<T>): Array<T> = block()
 inline fun <reified T> ok2(): Array<T> = Array(1) { null!! }
 
 
-fun <T> fail2(): Array<T> = ok1 { <!TYPE_PARAMETER_AS_REIFIED!>Array<!><T>(1) {  null!! } }
+fun <T> fail2(): Array<T> = ok1 { Array<<!TYPE_PARAMETER_AS_REIFIED!>T<!>>(1) {  null!! } }
 fun <T> ok3(block: () -> Array<T>): Array<T> = ok1 { block() }
 inline fun <reified T> ok4(): Array<T> = ok1 { Array<T>(1) { null!! } }
 

compiler/testData/diagnostics/testsWithStdLib/reified/arrayOfNullsReified.kt

@@ -1,7 +1,7 @@
 // !DIAGNOSTICS: -UNUSED_VARIABLE
 
 fun <T> foo() {
-    val x = <!TYPE_PARAMETER_AS_REIFIED!>arrayOfNulls<!><T>(5)
+    val x = arrayOfNulls<<!TYPE_PARAMETER_AS_REIFIED!>T<!>>(5)
 }
 
 inline fun <reified T> bar() {

compiler/testData/diagnostics/testsWithStdLib/reified/reifiedNothingSubstitution.kt

@@ -6,11 +6,11 @@ inline fun <reified T: Any> javaClass(): Class<T> = T::class.java
 
 fun box() {
     val a = <!UNSUPPORTED!><!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>arrayOf<!>(null!!)<!>
-    val b = <!UNSUPPORTED!><!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>Array<!><Nothing?>(5) { null!! }<!>
+    val b = <!UNSUPPORTED!>Array<<!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>Nothing?<!>>(5) { null!! }<!>
     val c = <!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>foo<!>() { null!! }
     val d = foo<Any> { null!! }
     val e = <!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>foo<!> { "1" as Nothing }
     val e1 = <!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>foo<!> { "1" as Nothing? }
 
-    val f = <!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>javaClass<!><Nothing>()
+    val f = javaClass<<!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>Nothing<!>>()
 }