AA: handle underscore as type arguments

^KTIJ-24742 Fixed

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtTypeProvider.kt

@@ -49,19 +49,19 @@ public interface KtTypeProviderMixIn : KtAnalysisSessionMixIn {
         get() = withValidityAssertion { analysisSession.typeProvider.builtinTypes }
 
     /**
-     * Approximates [KtType] with the a supertype which can be rendered in a source code
+     * Approximates [KtType] with a supertype which can be rendered in a source code
      *
      * Return `null` if the type do not need approximation and can be rendered as is
-     * Otherwise, for type `T` return type `S` such `T <: S` and `T` and every it type argument is denotable
+     * Otherwise, for type `T` return type `S` such `T <: S` and `T` and every type argument is denotable
      */
     public fun KtType.approximateToSuperPublicDenotable(approximateLocalTypes: Boolean): KtType? =
         withValidityAssertion { analysisSession.typeProvider.approximateToSuperPublicDenotableType(this, approximateLocalTypes) }
 
     /**
-     * Approximates [KtType] with the a subtype which can be rendered in a source code
+     * Approximates [KtType] with a subtype which can be rendered in a source code
      *
      * Return `null` if the type do not need approximation and can be rendered as is
-     * Otherwise, for type `T` return type `S` such `S <: T` and `T` and every it type argument is denotable
+     * Otherwise, for type `T` return type `S` such `S <: T` and `T` and every type argument is denotable
      */
     public fun KtType.approximateToSubPublicDenotable(approximateLocalTypes: Boolean): KtType? =
         withValidityAssertion { analysisSession.typeProvider.approximateToSubPublicDenotableType(this, approximateLocalTypes) }

analysis/analysis-api/testData/components/typeProvider/typeReference/starProjection.kt

@@ -0,0 +1,12 @@
+abstract class Base<T> {
+    abstract foo(arg: T): T
+}
+
+class StringSub : Base<String> {
+    override fun foo(arg: String) = arg + " = 42"
+}
+
+fun test() {
+    val x : Base<<caret>*> = StringSub()
+    x.foo("42")
+}

analysis/analysis-api/testData/components/typeProvider/typeReference/starProjection.txt

@@ -0,0 +1,2 @@
+expression: Base<*>
+ktType: Base<*>

analysis/analysis-api/testData/components/typeProvider/typeReference/superTypeEntry.kt

@@ -0,0 +1,3 @@
+open class Base
+
+class Sub : Bas<caret>e()

analysis/analysis-api/testData/components/typeProvider/typeReference/superTypeEntry.txt

@@ -0,0 +1,2 @@
+expression: Base
+ktType: Base

analysis/analysis-api/testData/components/typeProvider/typeReference/superTypeEntry_withTypeArgument.kt

@@ -0,0 +1,7 @@
+abstract class Base<T> {
+    abstract foo(arg: T): T
+}
+
+class StringSub : B<caret>ase<String> {
+    override fun foo(arg: String) = arg + " = 42"
+}

analysis/analysis-api/testData/components/typeProvider/typeReference/superTypeEntry_withTypeArgument.txt

@@ -0,0 +1,2 @@
+expression: Base<String>
+ktType: Base<kotlin.String>

analysis/analysis-api/testData/components/typeProvider/typeReference/typeArgument_functionCall.kt

@@ -0,0 +1,7 @@
+inline fun <T> foo(arg: T) {
+    println(arg.toString())
+}
+
+fun test() {
+    foo<Strin<caret>g>("42")
+}

analysis/analysis-api/testData/components/typeProvider/typeReference/typeArgument_functionCall.txt

@@ -0,0 +1,2 @@
+expression: String
+ktType: kotlin.String

analysis/analysis-api/testData/components/typeProvider/typeReference/typeArgument_superTypeEntry.kt

@@ -0,0 +1,7 @@
+abstract class Base<T> {
+    abstract foo(arg: T): T
+}
+
+class StringSub : Base<Strin<caret>g> {
+    override fun foo(arg: String) = arg + " = 42"
+}

analysis/analysis-api/testData/components/typeProvider/typeReference/typeArgument_superTypeEntry.txt

@@ -0,0 +1,2 @@
+expression: String
+ktType: kotlin.String

analysis/analysis-api/testData/components/typeProvider/typeReference/underscoreTypeArgument_inferred.kt

@@ -0,0 +1,32 @@
+// example from https://kotlinlang.org/docs/generics.html#underscore-operator-for-type-arguments
+// modified to avoid using reflection (::class.java)
+
+abstract class SomeClass<T> {
+    abstract fun execute() : T
+}
+
+class SomeImplementation : SomeClass<String>() {
+    override fun execute(): String = "Test"
+}
+
+class OtherImplementation : SomeClass<Int>() {
+    override fun execute(): Int = 42
+}
+
+object Runner {
+    inline fun <reified S: SomeClass<T>, T> run(instance: S) : T {
+        return instance.execute()
+    }
+}
+
+fun test() {
+    val i = SomeImplementation()
+    // T is inferred as String because SomeImplementation derives from SomeClass<String>
+    val s = Runner.run<_, _>(i)
+    assert(s == "Test")
+
+    val j = OtherImplementation()
+    // T is inferred as Int because OtherImplementation derives from SomeClass<Int>
+    val n = Runner.run<_, <caret>_>(j)
+    assert(n == 42)
+}

analysis/analysis-api/testData/components/typeProvider/typeReference/underscoreTypeArgument_inferred.txt

@@ -0,0 +1,2 @@
+expression: _
+ktType: kotlin.Int

analysis/analysis-api/testData/components/typeProvider/typeReference/underscoreTypeArgument_reified.kt

@@ -0,0 +1,32 @@
+// example from https://kotlinlang.org/docs/generics.html#underscore-operator-for-type-arguments
+// modified to avoid using reflection (::class.java)
+
+abstract class SomeClass<T> {
+    abstract fun execute() : T
+}
+
+class SomeImplementation : SomeClass<String>() {
+    override fun execute(): String = "Test"
+}
+
+class OtherImplementation : SomeClass<Int>() {
+    override fun execute(): Int = 42
+}
+
+object Runner {
+    inline fun <reified S: SomeClass<T>, T> run(instance: S) : T {
+        return instance.execute()
+    }
+}
+
+fun test() {
+    val i = SomeImplementation()
+    // T is inferred as String because SomeImplementation derives from SomeClass<String>
+    val s = Runner.run<_, _>(i)
+    assert(s == "Test")
+
+    val j = OtherImplementation()
+    // T is inferred as Int because OtherImplementation derives from SomeClass<Int>
+    val n = Runner.run<<caret>_, _>(j)
+    assert(n == 42)
+}

analysis/analysis-api/testData/components/typeProvider/typeReference/underscoreTypeArgument_reified.txt

@@ -0,0 +1,2 @@
+expression: _
+ktType: OtherImplementation