IR: support buildSimpleType for IrCapturedType

To make it possible to change nullability of IrCapturedType and change
its annotations, which is happening when determining overridability of
functions via IR.

 #KT-63437 Fixed

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirBlackBoxCodegenBasedTestGenerated.java

@@ -30564,6 +30564,12 @@ public class LLFirBlackBoxCodegenBasedTestGenerated extends AbstractLLFirBlackBo
             runTest("compiler/testData/codegen/box/javaInterop/genericSamSmartcast.kt");
         }
 
+        @Test
+        @TestMetadata("inheritanceWithWildcard.kt")
+        public void testInheritanceWithWildcard() throws Exception {
+            runTest("compiler/testData/codegen/box/javaInterop/inheritanceWithWildcard.kt");
+        }
+
         @Test
         @TestMetadata("javaInterfaceFieldDirectAccess.kt")
         public void testJavaInterfaceFieldDirectAccess() throws Exception {

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirReversedBlackBoxCodegenBasedTestGenerated.java

@@ -30564,6 +30564,12 @@ public class LLFirReversedBlackBoxCodegenBasedTestGenerated extends AbstractLLFi
             runTest("compiler/testData/codegen/box/javaInterop/genericSamSmartcast.kt");
         }
 
+        @Test
+        @TestMetadata("inheritanceWithWildcard.kt")
+        public void testInheritanceWithWildcard() throws Exception {
+            runTest("compiler/testData/codegen/box/javaInterop/inheritanceWithWildcard.kt");
+        }
+
         @Test
         @TestMetadata("javaInterfaceFieldDirectAccess.kt")
         public void testJavaInterfaceFieldDirectAccess() throws Exception {

compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirLightTreeBlackBoxCodegenTestGenerated.java

@@ -30169,6 +30169,12 @@ public class FirLightTreeBlackBoxCodegenTestGenerated extends AbstractFirLightTr
             runTest("compiler/testData/codegen/box/javaInterop/genericSamSmartcast.kt");
         }
 
+        @Test
+        @TestMetadata("inheritanceWithWildcard.kt")
+        public void testInheritanceWithWildcard() throws Exception {
+            runTest("compiler/testData/codegen/box/javaInterop/inheritanceWithWildcard.kt");
+        }
+
         @Test
         @TestMetadata("javaInterfaceFieldDirectAccess.kt")
         public void testJavaInterfaceFieldDirectAccess() throws Exception {

compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirLightTreeBlackBoxCodegenWithIrFakeOverrideGeneratorTestGenerated.java

@@ -30169,6 +30169,12 @@ public class FirLightTreeBlackBoxCodegenWithIrFakeOverrideGeneratorTestGenerated
             runTest("compiler/testData/codegen/box/javaInterop/genericSamSmartcast.kt");
         }
 
+        @Test
+        @TestMetadata("inheritanceWithWildcard.kt")
+        public void testInheritanceWithWildcard() throws Exception {
+            runTest("compiler/testData/codegen/box/javaInterop/inheritanceWithWildcard.kt");
+        }
+
         @Test
         @TestMetadata("javaInterfaceFieldDirectAccess.kt")
         public void testJavaInterfaceFieldDirectAccess() throws Exception {

compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirPsiBlackBoxCodegenTestGenerated.java

@@ -30169,6 +30169,12 @@ public class FirPsiBlackBoxCodegenTestGenerated extends AbstractFirPsiBlackBoxCo
             runTest("compiler/testData/codegen/box/javaInterop/genericSamSmartcast.kt");
         }
 
+        @Test
+        @TestMetadata("inheritanceWithWildcard.kt")
+        public void testInheritanceWithWildcard() throws Exception {
+            runTest("compiler/testData/codegen/box/javaInterop/inheritanceWithWildcard.kt");
+        }
+
         @Test
         @TestMetadata("javaInterfaceFieldDirectAccess.kt")
         public void testJavaInterfaceFieldDirectAccess() throws Exception {

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrTypeSystemContext.kt

@@ -262,7 +262,9 @@ interface IrTypeSystemContext : TypeSystemContext, TypeSystemCommonSuperTypesCon
                     argument.type
                 } else null
 
-                IrCapturedType(status, lowerType, argument, typeParameters[index])
+                IrCapturedType(
+                    status, lowerType, argument, typeParameters[index], SimpleTypeNullability.DEFINITELY_NOT_NULL, emptyList(), null
+                )
             }
         }
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/impl/IrSimpleTypeImpl.kt

@@ -10,8 +10,10 @@ import org.jetbrains.kotlin.ir.symbols.FqNameEqualityChecker
 import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol
 import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol
 import org.jetbrains.kotlin.ir.types.*
+import org.jetbrains.kotlin.ir.util.render
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.Variance
+import org.jetbrains.kotlin.types.model.CaptureStatus
 import org.jetbrains.kotlin.utils.compactIfPossible
 
 abstract class IrAbstractSimpleType(kotlinType: KotlinType?) : IrSimpleType(kotlinType) {
@@ -89,27 +91,60 @@ class IrSimpleTypeBuilder {
     var arguments: List<IrTypeArgument> = emptyList()
     var annotations: List<IrConstructorCall> = emptyList()
     var abbreviation: IrTypeAbbreviation? = null
+
+    var captureStatus: CaptureStatus? = null
+    var capturedLowerType: IrType? = null
+    var capturedTypeConstructor: IrCapturedType.Constructor? = null
 }
 
-fun IrSimpleType.toBuilder() =
+fun IrSimpleType.toBuilder(): IrSimpleTypeBuilder =
     IrSimpleTypeBuilder().also { b ->
         b.kotlinType = originalKotlinType
-        b.classifier = classifier
+        if (this is IrCapturedType) {
+            b.captureStatus = captureStatus
+            b.capturedLowerType = lowerType
+            b.capturedTypeConstructor = constructor
+        } else {
+            b.classifier = classifier
+        }
         b.nullability = nullability
         b.arguments = arguments
         b.annotations = annotations
         b.abbreviation = abbreviation
     }
 
-fun IrSimpleTypeBuilder.buildSimpleType() =
+fun IrSimpleTypeBuilder.buildSimpleType(): IrSimpleType =
-    IrSimpleTypeImpl(
+    if (classifier == null) {
-        kotlinType,
+        check(captureStatus != null && capturedTypeConstructor != null) {
-        classifier ?: throw AssertionError("Classifier not provided"),
+            "Neither classifier nor captured type constructor is provided"
-        nullability,
+        }
-        arguments.compactIfPossible(),
+        check(arguments.isEmpty()) {
-        annotations.compactIfPossible(),
+            "Arguments should be empty when creating a captured type: ${capturedTypeConstructor?.argument?.render()}"
-        abbreviation
+        }
-    )
+        IrCapturedType(
+            captureStatus!!,
+            capturedLowerType,
+            capturedTypeConstructor!!.argument,
+            capturedTypeConstructor!!.typeParameter,
+            nullability,
+            annotations.compactIfPossible(),
+            abbreviation,
+        ).apply {
+            constructor.initSuperTypes(capturedTypeConstructor!!.superTypes)
+        }
+    } else {
+        check(captureStatus == null && capturedTypeConstructor == null) {
+            "Both classifier and captured type constructor are provided"
+        }
+        IrSimpleTypeImpl(
+            kotlinType,
+            classifier ?: throw AssertionError("Classifier not provided"),
+            nullability,
+            arguments.compactIfPossible(),
+            annotations.compactIfPossible(),
+            abbreviation
+        )
+    }
 
 fun IrSimpleTypeBuilder.buildTypeProjection(variance: Variance): IrTypeProjection =
     if (variance == Variance.INVARIANT)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/impl/IrTypeBase.kt

@@ -71,7 +71,10 @@ class IrCapturedType(
     val captureStatus: CaptureStatus,
     val lowerType: IrType?,
     projection: IrTypeArgument,
-    typeParameter: IrTypeParameter
+    typeParameter: IrTypeParameter,
+    override val nullability: SimpleTypeNullability,
+    override val annotations: List<IrConstructorCall>,
+    override val abbreviation: IrTypeAbbreviation?,
 ) : IrSimpleType(null), CapturedTypeMarker {
     class Constructor(val argument: IrTypeArgument, val typeParameter: IrTypeParameter) : CapturedTypeConstructorMarker {
         var superTypes: List<IrType> = emptyList()
@@ -85,10 +88,8 @@ class IrCapturedType(
     val constructor: Constructor = Constructor(projection, typeParameter)
 
     override val classifier: IrClassifierSymbol get() = error("Captured Type does not have a classifier")
+
     override val arguments: List<IrTypeArgument> get() = emptyList()
-    override val abbreviation: IrTypeAbbreviation? get() = null
-    override val nullability: SimpleTypeNullability get() = SimpleTypeNullability.DEFINITELY_NOT_NULL
-    override val annotations: List<IrConstructorCall> get() = emptyList()
 
     override fun equals(other: Any?): Boolean = this === other
 

compiler/testData/codegen/box/javaInterop/inheritanceWithWildcard.kt

@@ -0,0 +1,28 @@
+// TARGET_BACKEND: JVM
+// IGNORE_LIGHT_ANALYSIS
+// FILE: A.java
+
+interface A {
+    X<? extends A> foo();
+
+    interface X<T extends A> {}
+}
+
+interface B extends A {
+    @Override
+    Y<? extends B> foo();
+
+    interface Y<U extends B> extends X<U> {}
+}
+
+class BImpl implements B {
+    @Override
+    public Y<? extends B> foo() { return null; }
+}
+
+// FILE: 1.kt
+
+private class D : A, BImpl()
+
+fun box(): String =
+    if (D().foo() == null) "OK" else "Fail"

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java

@@ -28471,6 +28471,12 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest {
             runTest("compiler/testData/codegen/box/javaInterop/genericSamSmartcast.kt");
         }
 
+        @Test
+        @TestMetadata("inheritanceWithWildcard.kt")
+        public void testInheritanceWithWildcard() throws Exception {
+            runTest("compiler/testData/codegen/box/javaInterop/inheritanceWithWildcard.kt");
+        }
+
         @Test
         @TestMetadata("javaOuterClassDependsOnInner.kt")
         public void testJavaOuterClassDependsOnInner() throws Exception {

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java

@@ -30169,6 +30169,12 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes
             runTest("compiler/testData/codegen/box/javaInterop/genericSamSmartcast.kt");
         }
 
+        @Test
+        @TestMetadata("inheritanceWithWildcard.kt")
+        public void testInheritanceWithWildcard() throws Exception {
+            runTest("compiler/testData/codegen/box/javaInterop/inheritanceWithWildcard.kt");
+        }
+
         @Test
         @TestMetadata("javaInterfaceFieldDirectAccess.kt")
         public void testJavaInterfaceFieldDirectAccess() throws Exception {

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenWithIrInlinerTestGenerated.java

@@ -30169,6 +30169,12 @@ public class IrBlackBoxCodegenWithIrInlinerTestGenerated extends AbstractIrBlack
             runTest("compiler/testData/codegen/box/javaInterop/genericSamSmartcast.kt");
         }
 
+        @Test
+        @TestMetadata("inheritanceWithWildcard.kt")
+        public void testInheritanceWithWildcard() throws Exception {
+            runTest("compiler/testData/codegen/box/javaInterop/inheritanceWithWildcard.kt");
+        }
+
         @Test
         @TestMetadata("javaInterfaceFieldDirectAccess.kt")
         public void testJavaInterfaceFieldDirectAccess() throws Exception {

compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java

@@ -25530,6 +25530,11 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes
             runTest("compiler/testData/codegen/box/javaInterop/genericSamSmartcast.kt");
         }
 
+        @TestMetadata("inheritanceWithWildcard.kt")
+        public void testInheritanceWithWildcard() throws Exception {
+            runTest("compiler/testData/codegen/box/javaInterop/inheritanceWithWildcard.kt");
+        }
+
         @TestMetadata("javaInterfaceFieldDirectAccess.kt")
         public void testJavaInterfaceFieldDirectAccess() throws Exception {
             runTest("compiler/testData/codegen/box/javaInterop/javaInterfaceFieldDirectAccess.kt");