From be9805ea5e3f6d85a3aec89a75fbb78ccd2beeff Mon Sep 17 00:00:00 2001 From: Vladimir Sukharev Date: Wed, 20 Dec 2023 09:44:49 +0100 Subject: [PATCH] [K2/N][Tests] Add test to demonstrate compiler behavior for ObjC properties intersection overrides ^KT-57640 --- .../testData/codegen/box/cinterop/kt57640.kt | 680 ++++++++++++++++++ .../FirNativeCodegenBoxTestGenerated.java | 6 + .../FirNativeCodegenBoxTestNoPLGenerated.java | 6 + .../NativeCodegenBoxTestGenerated.java | 6 + .../NativeCodegenBoxTestNoPLGenerated.java | 6 + 5 files changed, 704 insertions(+) create mode 100644 compiler/testData/codegen/box/cinterop/kt57640.kt diff --git a/compiler/testData/codegen/box/cinterop/kt57640.kt b/compiler/testData/codegen/box/cinterop/kt57640.kt new file mode 100644 index 00000000000..5174eea32b0 --- /dev/null +++ b/compiler/testData/codegen/box/cinterop/kt57640.kt @@ -0,0 +1,680 @@ +// TARGET_BACKEND: NATIVE +// MODULE: cinterop +// FILE: kt57640.def +language = Objective-C +headers = kt57640.h + +// FILE: kt57640.h +#import + +@interface Base : NSObject +@property (readwrite) Base* delegate; +@end + +@protocol Foo +@property (readwrite) id delegate; +@end + +@protocol Bar +@property (readwrite) id delegate; +@end + +@interface Derived : Base +// This interface does not have re-declaration of property `delegate`. +// Return type of getter `delegate()` and param type of setter `setDelegate()` are: +// the type of property defined in the first mentioned protocol (id), which is incompatible with property type. +@end + +@interface DerivedWithPropertyOverride : Base +// This interface does not have re-declaration of property `delegate`. +// Return type of getter `delegate()` and param type of setter `setDelegate()` are `DerivedWithPropertyOverride*` +@property (readwrite) DerivedWithPropertyOverride* delegate; +@end + +// FILE: kt57640.m +#import "kt57640.h" + +@implementation Base +@end + +@implementation Derived +@end + +@implementation DerivedWithPropertyOverride +@end + +// MODULE: main(cinterop) +// FILE: main.kt +@file:OptIn(kotlinx.cinterop.ExperimentalForeignApi::class) +import kt57640.* +import kotlin.test.* + +class GrandDerived: Derived() {} +class GrandDerivedWithPropertyOverride: DerivedWithPropertyOverride() {} + +/** + * class KotlinInterfaceDerived would cause errors, this deserves a diagnostic test + * error: class 'KotlinInterfaceDerived' must override 'delegate' because it inherits multiple implementations for it. + * error: 'delegate' clashes with 'delegate': return types are incompatible. + * error: 'delegate' clashes with 'delegate': property types do not match. + */ +//class KotlinInterfaceDerived: Base(), FooProtocol, BarProtocol + +fun box(): String { + testBase() + + testAssignmentDerivedToDerived() + testAssignmentDerivedToBase() + testAssignmentBaseToDerived() + + testAssignmentDerivedWithPropertyOverrideToDerivedWithPropertyOverride() + testAssignmentDerivedWithPropertyOverrideToBase() + testAssignmentBaseToDerivedWithPropertyOverride() + + testGrandDerived() + testGrandDerivedWithPropertyOverride() + testAssigmmentDerivedWithPropertyOverrideToGrandDerivedWithPropertyOverride() + + return "OK" +} + +private fun testBase() { + val base = Base() + val delegate00_Base: Base? = base.delegate + assertEquals(null, delegate00_Base) + val delegate01_Base: Base? = base.delegate() + assertEquals(null, delegate01_Base) + + base.delegate = base + val delegate02_Base: Base? = base.delegate + assertEquals(base, delegate02_Base) + val delegate03_Base: Base? = base.delegate() + assertEquals(base, delegate03_Base) +} + +private fun testAssignmentDerivedToDerived() { + val derived = Derived() + val delegate10_Base: Base? = derived.delegate + assertEquals(null, delegate10_Base) + val delegate11_Bar: BarProtocol? = derived.delegate() + assertEquals(null, delegate11_Bar) + + derived.delegate = derived + derived.setDelegate(derived) + + val delegate12_Base: Base? = derived.delegate + assertTrue(delegate12_Base is Base) + assertTrue(delegate12_Base is FooProtocol) + assertTrue(delegate12_Base is BarProtocol) + assertTrue(delegate12_Base is Derived) + assertEquals(derived, delegate12_Base) + val delegate16_Bar: BarProtocol? = derived.delegate() + assertTrue(delegate16_Bar is Base) + assertTrue(delegate16_Bar is FooProtocol) + assertTrue(delegate16_Bar is BarProtocol) + assertTrue(delegate16_Bar is Derived) + assertEquals(derived, delegate16_Bar) + + val delegate13_Base: Base? = (derived as Base).delegate + assertTrue(delegate13_Base is Base) + assertTrue(delegate13_Base is FooProtocol) + assertTrue(delegate13_Base is BarProtocol) + assertTrue(delegate13_Base is Derived) + assertEquals(derived, delegate13_Base) + val delegate17_Base: Base? = (derived as Base).delegate() + assertTrue(delegate17_Base is Base) + assertTrue(delegate17_Base is FooProtocol) + assertTrue(delegate17_Base is BarProtocol) + assertTrue(delegate17_Base is Derived) + assertEquals(derived, delegate17_Base) + + val delegate14_Foo: FooProtocol? = (derived as FooProtocol).delegate + assertTrue(delegate14_Foo is Base) + assertTrue(delegate14_Foo is FooProtocol) + assertTrue(delegate14_Foo is BarProtocol) + assertTrue(delegate14_Foo is Derived) + assertEquals(derived, delegate14_Foo) + val delegate18_Foo: FooProtocol? = (derived as FooProtocol).delegate() + assertTrue(delegate18_Foo is Base) + assertTrue(delegate18_Foo is FooProtocol) + assertTrue(delegate18_Foo is BarProtocol) + assertTrue(delegate18_Foo is Derived) + assertEquals(derived, delegate18_Foo) + + val delegate15_Bar: BarProtocol? = (derived as BarProtocol).delegate + assertTrue(delegate15_Bar is Base) + assertTrue(delegate15_Bar is FooProtocol) + assertTrue(delegate15_Bar is BarProtocol) + assertTrue(delegate15_Bar is Derived) + assertEquals(derived, delegate15_Bar) + val delegate19_Bar: BarProtocol? = (derived as BarProtocol).delegate() + assertTrue(delegate19_Bar is Base) + assertTrue(delegate19_Bar is FooProtocol) + assertTrue(delegate19_Bar is BarProtocol) + assertTrue(delegate19_Bar is Derived) + assertEquals(derived, delegate19_Bar) +} + +private fun testAssignmentDerivedToBase() { + val base = Base() + val delegate10_Base: Base? = base.delegate + assertEquals(null, delegate10_Base) + val delegate11_Base: Base? = base.delegate() + assertEquals(null, delegate11_Base) + + base.delegate = base + base.setDelegate(base) + val derived = Derived() + base.delegate = derived + + val delegate12_Base: Base? = base.delegate + assertTrue(delegate12_Base is Base) + assertTrue(delegate12_Base is FooProtocol) + assertTrue(delegate12_Base is BarProtocol) + assertTrue(delegate12_Base is Derived) + assertEquals(derived, delegate12_Base) + val delegate16_Base: Base? = base.delegate() + assertTrue(delegate16_Base is Base) + assertTrue(delegate16_Base is FooProtocol) + assertTrue(delegate16_Base is BarProtocol) + assertTrue(delegate16_Base is Derived) + assertEquals(derived, delegate16_Base) +} + +private fun testAssignmentBaseToDerived() { + val derived = Derived() + val delegate10_Base: Base? = derived.delegate + assertEquals(null, delegate10_Base) + val delegate11_Bar: BarProtocol? = derived.delegate() + assertEquals(null, delegate11_Bar) + + val base = Base() + derived.delegate = base +// derived.setDelegate(base) // argument type mismatch, this deserves a diagnostic test + + val delegate12_Base: Base? = derived.delegate + assertTrue(delegate12_Base is Base) + assertFalse(delegate12_Base is FooProtocol) + assertFalse(delegate12_Base is BarProtocol) + assertFalse(delegate12_Base is Derived) + assertEquals(base, delegate12_Base) + val delegate16_Bar: BarProtocol? = derived.delegate() + val delegate16_Any: Any? = delegate16_Bar + assertTrue(delegate16_Bar is Base) + assertTrue(delegate16_Any is Base) + assertFalse(delegate16_Bar is FooProtocol) + assertFalse(delegate16_Any is FooProtocol) +// Behavior of next "is" check depends on existence of static type analysis: static analysis calculates "is" result as "true", +// while at run-time, the type is Base, which isn't BarProtocol, and the "is" result is "false" +// assertFalse(delegate16_Bar is BarProtocol) + assertFalse(delegate16_Any is BarProtocol) // actual type is Base, which isn't BarProtocol + assertFalse(delegate16_Bar is Derived) + assertFalse(delegate16_Any is Derived) + assertEquals(base, delegate16_Bar) + assertEquals(base, delegate16_Any) + + val delegate13_Base: Base? = (derived as Base).delegate + assertTrue(delegate13_Base is Base) + assertFalse(delegate13_Base is FooProtocol) + assertFalse(delegate13_Base is BarProtocol) + assertFalse(delegate13_Base is Derived) + assertEquals(base, delegate13_Base) + val delegate17_Base: Base? = (derived as Base).delegate() + assertTrue(delegate17_Base is Base) + assertFalse(delegate17_Base is FooProtocol) + assertFalse(delegate17_Base is BarProtocol) + assertFalse(delegate17_Base is Derived) + assertEquals(base, delegate17_Base) + + val delegate14_Foo: FooProtocol? = (derived as FooProtocol).delegate + val delegate14_Any: Any? = delegate14_Foo + assertTrue(delegate14_Foo is Base) + assertTrue(delegate14_Any is Base) +// Behavior of next "is" check depends on existence of static type analysis: static analysis calculates "is" result as "true", +// while at run-time, the type is Base, which isn't FooProtocol, and the "is" result is "false" +// assertFalse(delegate14_Foo is FooProtocol) + assertFalse(delegate14_Any is FooProtocol) // actual type is Base, which isn't FooProtocol + assertFalse(delegate14_Foo is BarProtocol) + assertFalse(delegate14_Any is BarProtocol) + assertFalse(delegate14_Foo is Derived) + assertEquals(base, delegate14_Foo as Base) + assertEquals(base, delegate14_Any as Base) + + val delegate18_Foo: FooProtocol? = (derived as FooProtocol).delegate() + val delegate18_Any: Any? = delegate18_Foo + assertTrue(delegate18_Foo is Base) + assertTrue(delegate18_Any is Base) +// Behavior of next "is" check depends on existence of static type analysis: static analysis calculates "is" result as "true", +// while at run-time, the type is Base, which isn't FooProtocol, and the "is" result is "false" +// assertFalse(delegate18_Foo is FooProtocol) + assertFalse(delegate18_Any is FooProtocol) // actual type is Base, which isn't FooProtocol + assertFalse(delegate18_Foo is BarProtocol) + assertFalse(delegate18_Any is BarProtocol) + assertFalse(delegate18_Foo is Derived) + assertFalse(delegate18_Any is Derived) + assertEquals(base, delegate18_Foo) + assertEquals(base, delegate18_Any) + + val delegate15_Bar: BarProtocol? = (derived as BarProtocol).delegate + val delegate15_Any: Any? = delegate15_Bar + assertTrue(delegate15_Bar is Base) + assertTrue(delegate15_Any is Base) + assertFalse(delegate15_Bar is FooProtocol) + assertFalse(delegate15_Any is FooProtocol) +// Behavior of next "is" check depends on existence of static type analysis: static analysis calculates "is" result as "true", +// while at run-time, the type is Base, which isn't BarProtocol, and the "is" result is "false" +// assertFalse(delegate15_Bar is BarProtocol) + assertFalse(delegate15_Any is BarProtocol) // actual type is Base, which isn't BarProtocol + assertFalse(delegate15_Bar is Derived) + assertFalse(delegate15_Any is Derived) + assertEquals(base, delegate15_Bar as Base) + assertEquals(base, delegate15_Any as Base) + + val delegate19_Bar: BarProtocol? = (derived as BarProtocol).delegate() + val delegate19_Any: Any? = delegate19_Bar + assertTrue(delegate19_Bar is Base) + assertTrue(delegate19_Any is Base) + assertFalse(delegate19_Bar is FooProtocol) + assertFalse(delegate19_Any is FooProtocol) +// Behavior of next "is" check depends on existence of static type analysis: static analysis calculates "is" result as "true", +// while at run-time, the type is Base, which isn't BarProtocol, and the "is" result is "false" +// assertFalse(delegate19_Bar is BarProtocol) + assertFalse(delegate19_Any is BarProtocol) // actual type is Base, which isn't BarProtocol + assertFalse(delegate19_Bar is Derived) + assertFalse(delegate19_Any is Derived) + assertEquals(base, delegate19_Bar) + assertEquals(base, delegate19_Any) +} + +private fun testAssignmentDerivedWithPropertyOverrideToDerivedWithPropertyOverride() { + val derived = DerivedWithPropertyOverride() + // WARNING: static type of backing field in CInterop KLib is `Base?`, but not expected `DerivedWithPropertyOverride?`. Comments below are related + val delegate10_Base: Base? = derived.delegate + assertEquals(null, delegate10_Base) + val delegate11_Bar: BarProtocol? = derived.delegate() + assertEquals(null, delegate11_Bar) + + derived.delegate = derived + derived.setDelegate(derived) + + val delegate12_Base: Base? = derived.delegate // static type is Base?, not DerivedWithPropertyOverride?, this deserves a diagnostic test + assertTrue(delegate12_Base is Base) + assertTrue(delegate12_Base is FooProtocol) + assertTrue(delegate12_Base is BarProtocol) + assertTrue(delegate12_Base is DerivedWithPropertyOverride) + assertEquals(derived, delegate12_Base) + val delegate19_DerivedWithPropertyOverride: DerivedWithPropertyOverride? = derived.delegate() + assertTrue(delegate19_DerivedWithPropertyOverride is Base) + assertTrue(delegate19_DerivedWithPropertyOverride is FooProtocol) + assertTrue(delegate19_DerivedWithPropertyOverride is BarProtocol) + assertTrue(delegate19_DerivedWithPropertyOverride is DerivedWithPropertyOverride) + assertEquals(derived, delegate19_DerivedWithPropertyOverride) + + val delegate13_Base: Base? = (derived as Base).delegate + assertTrue(delegate13_Base is Base) + assertTrue(delegate13_Base is FooProtocol) + assertTrue(delegate13_Base is BarProtocol) + assertTrue(delegate13_Base is DerivedWithPropertyOverride) + assertEquals(derived, delegate13_Base) + val delegate17_Base: Base? = (derived as Base).delegate() // static type is Base?, not DerivedWithPropertyOverride?, this deserves a diagnostic test + assertTrue(delegate17_Base is Base) + assertTrue(delegate17_Base is FooProtocol) + assertTrue(delegate17_Base is BarProtocol) + assertTrue(delegate17_Base is DerivedWithPropertyOverride) + assertEquals(derived, delegate17_Base) + + val delegate14_Foo: FooProtocol? = (derived as FooProtocol).delegate + assertTrue(delegate14_Foo is Base) + assertTrue(delegate14_Foo is FooProtocol) + assertTrue(delegate14_Foo is BarProtocol) + assertTrue(delegate14_Foo is DerivedWithPropertyOverride) + assertEquals(derived, delegate14_Foo) + val delegate18_Foo: FooProtocol? = (derived as FooProtocol).delegate() // static type is FooProtocol?, not DerivedWithPropertyOverride?, this deserves a diagnostic test + assertTrue(delegate18_Foo is Base) + assertTrue(delegate18_Foo is FooProtocol) + assertTrue(delegate18_Foo is BarProtocol) + assertTrue(delegate18_Foo is DerivedWithPropertyOverride) + assertEquals(derived, delegate18_Foo) + + val delegate15_Bar: BarProtocol? = (derived as BarProtocol).delegate + assertTrue(delegate15_Bar is Base) + assertTrue(delegate15_Bar is FooProtocol) + assertTrue(delegate15_Bar is BarProtocol) + assertTrue(delegate15_Bar is DerivedWithPropertyOverride) + assertEquals(derived, delegate15_Bar) + val delegate19_Bar: BarProtocol? = (derived as BarProtocol).delegate() // static type is BarProtocol?, not DerivedWithPropertyOverride?, this deserves a diagnostic test + assertTrue(delegate19_Bar is Base) + assertTrue(delegate19_Bar is FooProtocol) + assertTrue(delegate19_Bar is BarProtocol) + assertTrue(delegate19_Bar is DerivedWithPropertyOverride) + assertEquals(derived, delegate19_Bar) +} + +private fun testAssignmentDerivedWithPropertyOverrideToBase() { + val base = Base() + val delegate10_Base: Base? = base.delegate + assertEquals(null, delegate10_Base) + val delegate11_Base: Base? = base.delegate() + assertEquals(null, delegate11_Base) + + val derived = DerivedWithPropertyOverride() + base.delegate = derived + base.setDelegate(derived) + + val delegate12_Base: Base? = base.delegate + assertTrue(delegate12_Base is Base) + assertTrue(delegate12_Base is FooProtocol) + assertTrue(delegate12_Base is BarProtocol) + assertTrue(delegate12_Base is DerivedWithPropertyOverride) + assertEquals(derived, delegate12_Base) + val delegate19_Base: Base? = base.delegate() + assertTrue(delegate19_Base is Base) + assertTrue(delegate19_Base is FooProtocol) + assertTrue(delegate19_Base is BarProtocol) + assertTrue(delegate19_Base is DerivedWithPropertyOverride) + assertEquals(derived, delegate19_Base) +} + +private fun testAssignmentBaseToDerivedWithPropertyOverride() { + val derived = DerivedWithPropertyOverride() + // WARNING: static type of backing field in CInterop KLib is `Base?`, but not expected `DerivedWithPropertyOverride?`. Comments below are related + val delegate10_Base: Base? = derived.delegate + assertEquals(null, delegate10_Base) + val delegate11_Bar: BarProtocol? = derived.delegate() + assertEquals(null, delegate11_Bar) + + val base = Base() + derived.delegate = base +// derived.setDelegate(base) // argument type mismatch: actual type is 'library.Base', but 'library.DerivedWithPropertyOverride?' was expected, this deserves a diagnostic test + + val delegate12_Base: Base? = derived.delegate // static type is Base?, not DerivedWithPropertyOverride?, this deserves a diagnostic test + assertTrue(delegate12_Base is Base) + assertFalse(delegate12_Base is FooProtocol) + assertFalse(delegate12_Base is BarProtocol) + assertFalse(delegate12_Base is DerivedWithPropertyOverride) + assertEquals(base, delegate12_Base) + val delegate19_DerivedWithPropertyOverride: DerivedWithPropertyOverride? = derived.delegate() + assertTrue(delegate19_DerivedWithPropertyOverride is Base) + assertTrue(delegate19_DerivedWithPropertyOverride is FooProtocol) + assertTrue(delegate19_DerivedWithPropertyOverride is BarProtocol) + assertTrue(delegate19_DerivedWithPropertyOverride is DerivedWithPropertyOverride) + assertEquals(base, delegate19_DerivedWithPropertyOverride) + + val delegate13_Base: Base? = (derived as Base).delegate + assertTrue(delegate13_Base is Base) + assertFalse(delegate13_Base is FooProtocol) + assertFalse(delegate13_Base is BarProtocol) + assertFalse(delegate13_Base is DerivedWithPropertyOverride) + assertEquals(base, delegate13_Base) + val delegate17_Base: Base? = (derived as Base).delegate() // static type is Base?, not DerivedWithPropertyOverride?, this deserves a diagnostic test + assertTrue(delegate17_Base is Base) + assertFalse(delegate17_Base is FooProtocol) + assertFalse(delegate17_Base is BarProtocol) + assertFalse(delegate17_Base is DerivedWithPropertyOverride) + assertEquals(base, delegate17_Base) + + val delegate14_Foo: FooProtocol? = (derived as FooProtocol).delegate + assertTrue(delegate14_Foo is Base) +// Behavior of next "is" check depends on existence of static type analysis: static analysis calculates "is" result as "true", +// while at run-time, the type is Base, which isn't FooProtocol, and the "is" result is "false" +// assertFalse(delegate14_Foo is FooProtocol) + assertFalse(delegate14_Foo is BarProtocol) + assertFalse(delegate14_Foo is DerivedWithPropertyOverride) + assertEquals(base, delegate14_Foo) + val delegate18_Foo: FooProtocol? = (derived as FooProtocol).delegate() // static type is FooProtocol?, not DerivedWithPropertyOverride?, this deserves a diagnostic test + assertTrue(delegate18_Foo is Base) +// Behavior of next "is" check depends on existence of static type analysis: static analysis calculates "is" result as "true", +// while at run-time, the type is Base, which isn't FooProtocol, and the "is" result is "false" +// assertFalse(delegate18_Foo is FooProtocol) + assertFalse(delegate18_Foo is BarProtocol) + assertFalse(delegate18_Foo is DerivedWithPropertyOverride) + assertEquals(base, delegate18_Foo) + + val delegate15_Bar: BarProtocol? = (derived as BarProtocol).delegate + assertTrue(delegate15_Bar is Base) + assertFalse(delegate15_Bar is FooProtocol) +// Behavior of next "is" check depends on existence of static type analysis: static analysis calculates "is" result as "true", +// while at run-time, the type is Base, which isn't BarProtocol, and the "is" result is "false" +// assertFalse(delegate15_Bar is BarProtocol) + assertFalse(delegate15_Bar is DerivedWithPropertyOverride) + assertEquals(base, delegate15_Bar) + val delegate19_Bar: BarProtocol? = (derived as BarProtocol).delegate() // static type is BarProtocol?, not DerivedWithPropertyOverride?, this deserves a diagnostic test + assertTrue(delegate19_Bar is Base) + assertFalse(delegate19_Bar is FooProtocol) +// Behavior of next "is" check depends on existence of static type analysis: static analysis calculates "is" result as "true", +// while at run-time, the type is Base, which isn't BarProtocol, and the "is" result is "false" +// assertFalse(delegate19_Bar is BarProtocol) + assertFalse(delegate19_Bar is DerivedWithPropertyOverride) + assertEquals(base, delegate19_Bar) +} + +private fun testGrandDerived() { + val grandDerived = GrandDerived() + val delegate10_Base: Base? = grandDerived.delegate + assertEquals(null, delegate10_Base) + val delegate11_Bar: BarProtocol? = grandDerived.delegate() + assertEquals(null, delegate11_Bar) + + grandDerived.delegate = Base() +// grandDerived.setDelegate(Base()) // argument type mismatch: actual type is 'library.Base', but 'library.BarProtocol?' was expected, this deserves a diagnostic test + grandDerived.delegate = Derived() + grandDerived.setDelegate(Derived()) + grandDerived.delegate = grandDerived + grandDerived.setDelegate(grandDerived) + + val delegate12_Base: Base? = grandDerived.delegate + assertTrue(delegate12_Base is Base) + assertTrue(delegate12_Base is FooProtocol) + assertTrue(delegate12_Base is BarProtocol) + assertTrue(delegate12_Base is Derived) + assertTrue(delegate12_Base is GrandDerived) + assertEquals(grandDerived, delegate12_Base) + val delegate21_Bar: BarProtocol? = grandDerived.delegate() + assertTrue(delegate21_Bar is Base) + assertTrue(delegate21_Bar is FooProtocol) + assertTrue(delegate21_Bar is BarProtocol) + assertTrue(delegate21_Bar is Derived) + assertTrue(delegate21_Bar is GrandDerived) + assertEquals(grandDerived, delegate21_Bar) + + val delegate13_Base: Base? = (grandDerived as Base).delegate + assertTrue(delegate13_Base is Base) + assertTrue(delegate13_Base is FooProtocol) + assertTrue(delegate13_Base is BarProtocol) + assertTrue(delegate13_Base is Derived) + assertTrue(delegate13_Base is GrandDerived) + assertEquals(grandDerived, delegate13_Base) + val delegate17_Base: Base? = (grandDerived as Base).delegate() + assertTrue(delegate17_Base is Base) + assertTrue(delegate17_Base is FooProtocol) + assertTrue(delegate17_Base is BarProtocol) + assertTrue(delegate17_Base is Derived) + assertTrue(delegate17_Base is GrandDerived) + assertEquals(grandDerived, delegate17_Base) + + val delegate14_Foo: FooProtocol? = (grandDerived as FooProtocol).delegate + assertTrue(delegate14_Foo is Base) + assertTrue(delegate14_Foo is FooProtocol) + assertTrue(delegate14_Foo is BarProtocol) + assertTrue(delegate14_Foo is Derived) + assertTrue(delegate14_Foo is GrandDerived) + assertEquals(grandDerived, delegate14_Foo) + val delegate18_Foo: FooProtocol? = (grandDerived as FooProtocol).delegate() + assertTrue(delegate18_Foo is Base) + assertTrue(delegate18_Foo is FooProtocol) + assertTrue(delegate18_Foo is BarProtocol) + assertTrue(delegate18_Foo is Derived) + assertTrue(delegate18_Foo is GrandDerived) + assertEquals(grandDerived, delegate18_Foo) + + val delegate15_Bar: BarProtocol? = (grandDerived as BarProtocol).delegate + assertTrue(delegate15_Bar is Base) + assertTrue(delegate15_Bar is FooProtocol) + assertTrue(delegate15_Bar is BarProtocol) + assertTrue(delegate15_Bar is Derived) + assertTrue(delegate15_Bar is GrandDerived) + assertEquals(grandDerived, delegate15_Bar) + val delegate19_Bar: BarProtocol? = (grandDerived as BarProtocol).delegate() + assertTrue(delegate19_Bar is Base) + assertTrue(delegate19_Bar is FooProtocol) + assertTrue(delegate19_Bar is BarProtocol) + assertTrue(delegate19_Bar is Derived) + assertTrue(delegate19_Bar is GrandDerived) + assertEquals(grandDerived, delegate19_Bar) + + val delegate16_Base: Base? = (grandDerived as Derived).delegate + assertTrue(delegate16_Base is Base) + assertTrue(delegate16_Base is FooProtocol) + assertTrue(delegate16_Base is BarProtocol) + assertTrue(delegate16_Base is Derived) + assertTrue(delegate16_Base is GrandDerived) + assertEquals(grandDerived, delegate16_Base) + val delegate20_Bar: BarProtocol? = (grandDerived as Derived).delegate() + assertTrue(delegate20_Bar is Base) + assertTrue(delegate20_Bar is FooProtocol) + assertTrue(delegate20_Bar is BarProtocol) + assertTrue(delegate20_Bar is Derived) + assertTrue(delegate20_Bar is GrandDerived) + assertEquals(grandDerived, delegate20_Bar) +} + +private fun testGrandDerivedWithPropertyOverride() { + val grandDerived = GrandDerivedWithPropertyOverride() + val delegate10_Base: Base? = grandDerived.delegate + assertEquals(null, delegate10_Base) + val delegate11_Bar: BarProtocol? = grandDerived.delegate() + assertEquals(null, delegate11_Bar) + + grandDerived.delegate = Base() +// grandDerived.setDelegate(Base()) // argument type mismatch: actual type is 'library.Base', but 'library.DerivedWithPropertyOverride?' was expected, this deserves a diagnostic test + grandDerived.delegate = Derived() +// grandDerived.setDelegate(Derived()) // argument type mismatch: actual type is 'library.Derived', but 'library.DerivedWithPropertyOverride?' was expected, this deserves a diagnostic test + grandDerived.delegate = DerivedWithPropertyOverride() + grandDerived.setDelegate(DerivedWithPropertyOverride()) + grandDerived.delegate = grandDerived + grandDerived.setDelegate(grandDerived) + + val delegate12_Base: Base? = grandDerived.delegate + assertTrue(delegate12_Base is Base) + assertTrue(delegate12_Base is FooProtocol) + assertTrue(delegate12_Base is BarProtocol) + assertTrue(delegate12_Base is DerivedWithPropertyOverride) + assertTrue(delegate12_Base is GrandDerivedWithPropertyOverride) + assertEquals(grandDerived, delegate12_Base) + + val delegate13_Base: Base? = (grandDerived as Base).delegate + assertTrue(delegate13_Base is Base) + assertTrue(delegate13_Base is FooProtocol) + assertTrue(delegate13_Base is BarProtocol) + assertTrue(delegate13_Base is DerivedWithPropertyOverride) + assertTrue(delegate13_Base is GrandDerivedWithPropertyOverride) + assertEquals(grandDerived, delegate13_Base) + + val delegate14_Foo: FooProtocol? = (grandDerived as FooProtocol).delegate + assertTrue(delegate14_Foo is Base) + assertTrue(delegate14_Foo is FooProtocol) + assertTrue(delegate14_Foo is BarProtocol) + assertTrue(delegate14_Foo is DerivedWithPropertyOverride) + assertTrue(delegate14_Foo is GrandDerivedWithPropertyOverride) + assertEquals(grandDerived, delegate14_Foo) + + val delegate15_Bar: BarProtocol? = (grandDerived as BarProtocol).delegate + assertTrue(delegate15_Bar is Base) + assertTrue(delegate15_Bar is FooProtocol) + assertTrue(delegate15_Bar is BarProtocol) + assertTrue(delegate15_Bar is DerivedWithPropertyOverride) + assertTrue(delegate15_Bar is GrandDerivedWithPropertyOverride) + assertEquals(grandDerived, delegate15_Bar) + + val delegate16_DerivedWithPropertyOverride: DerivedWithPropertyOverride? = grandDerived.delegate() + assertTrue(delegate16_DerivedWithPropertyOverride is Base) + assertTrue(delegate16_DerivedWithPropertyOverride is FooProtocol) + assertTrue(delegate16_DerivedWithPropertyOverride is BarProtocol) + assertTrue(delegate16_DerivedWithPropertyOverride is DerivedWithPropertyOverride) + assertTrue(delegate16_DerivedWithPropertyOverride is GrandDerivedWithPropertyOverride) + assertEquals(grandDerived, delegate16_DerivedWithPropertyOverride) + + val delegate17_Base: Base? = (grandDerived as Base).delegate() + assertTrue(delegate17_Base is Base) + assertTrue(delegate17_Base is FooProtocol) + assertTrue(delegate17_Base is BarProtocol) + assertTrue(delegate17_Base is DerivedWithPropertyOverride) + assertTrue(delegate17_Base is GrandDerivedWithPropertyOverride) + assertEquals(grandDerived, delegate17_Base) + + val delegate18_FooProtocol: FooProtocol? = (grandDerived as FooProtocol).delegate() + assertTrue(delegate18_FooProtocol is Base) + assertTrue(delegate18_FooProtocol is FooProtocol) + assertTrue(delegate18_FooProtocol is BarProtocol) + assertTrue(delegate18_FooProtocol is DerivedWithPropertyOverride) + assertTrue(delegate18_FooProtocol is GrandDerivedWithPropertyOverride) + assertEquals(grandDerived, delegate18_FooProtocol) + + val delegate19_BarProtocol: BarProtocol? = (grandDerived as BarProtocol).delegate() + assertTrue(delegate19_BarProtocol is Base) + assertTrue(delegate19_BarProtocol is FooProtocol) + assertTrue(delegate19_BarProtocol is BarProtocol) + assertTrue(delegate19_BarProtocol is DerivedWithPropertyOverride) + assertTrue(delegate19_BarProtocol is GrandDerivedWithPropertyOverride) + assertEquals(grandDerived, delegate19_BarProtocol) + + val delegate20_DerivedWithPropertyOverride: DerivedWithPropertyOverride? = (grandDerived as DerivedWithPropertyOverride).delegate() + assertTrue(delegate20_DerivedWithPropertyOverride is Base) + assertTrue(delegate20_DerivedWithPropertyOverride is FooProtocol) + assertTrue(delegate20_DerivedWithPropertyOverride is BarProtocol) + assertTrue(delegate20_DerivedWithPropertyOverride is DerivedWithPropertyOverride) + assertTrue(delegate20_DerivedWithPropertyOverride is GrandDerivedWithPropertyOverride) + assertEquals(grandDerived, delegate20_DerivedWithPropertyOverride) +} + +private fun testAssigmmentDerivedWithPropertyOverrideToGrandDerivedWithPropertyOverride() { + val grandDerived = GrandDerivedWithPropertyOverride() + val delegate10_Base: Base? = grandDerived.delegate + assertEquals(null, delegate10_Base) + val delegate11_Bar: BarProtocol? = grandDerived.delegate() + assertEquals(null, delegate11_Bar) + + val derived = DerivedWithPropertyOverride() + grandDerived.delegate = derived + grandDerived.setDelegate(derived) // argument type mismatch: actual type is 'library.Base', but 'library.DerivedWithPropertyOverride?' was expected, this deserves a diagnostic test + + val delegate12_Base: Base? = grandDerived.delegate + assertTrue(delegate12_Base is Base) + assertTrue(delegate12_Base is FooProtocol) + assertTrue(delegate12_Base is BarProtocol) + assertTrue(delegate12_Base is DerivedWithPropertyOverride) + assertFalse(delegate12_Base is GrandDerivedWithPropertyOverride) + assertEquals(derived, delegate12_Base) + + val delegate13_Base: Base? = (grandDerived as Base).delegate + assertTrue(delegate13_Base is Base) + assertTrue(delegate13_Base is FooProtocol) + assertTrue(delegate13_Base is BarProtocol) + assertTrue(delegate13_Base is DerivedWithPropertyOverride) + assertFalse(delegate13_Base is GrandDerivedWithPropertyOverride) + assertEquals(derived, delegate13_Base) + + val delegate14_Foo: FooProtocol? = (grandDerived as FooProtocol).delegate + assertTrue(delegate14_Foo is Base) + assertTrue(delegate14_Foo is FooProtocol) + assertTrue(delegate14_Foo is BarProtocol) + assertTrue(delegate14_Foo is DerivedWithPropertyOverride) + assertFalse(delegate14_Foo is GrandDerivedWithPropertyOverride) + assertEquals(derived, delegate14_Foo) + + val delegate15_Bar: BarProtocol? = (grandDerived as BarProtocol).delegate + assertTrue(delegate15_Bar is Base) + assertTrue(delegate15_Bar is FooProtocol) + assertTrue(delegate15_Bar is BarProtocol) + assertTrue(delegate15_Bar is DerivedWithPropertyOverride) + assertFalse(delegate15_Bar is GrandDerivedWithPropertyOverride) + assertEquals(derived, delegate15_Bar) + + val delegate16_DerivedWithPropertyOverride: DerivedWithPropertyOverride? = (grandDerived as DerivedWithPropertyOverride).delegate() + assertTrue(delegate16_DerivedWithPropertyOverride is Base) + assertTrue(delegate16_DerivedWithPropertyOverride is FooProtocol) + assertTrue(delegate16_DerivedWithPropertyOverride is BarProtocol) + assertTrue(delegate16_DerivedWithPropertyOverride is DerivedWithPropertyOverride) + assertFalse(delegate16_DerivedWithPropertyOverride is GrandDerivedWithPropertyOverride) + assertEquals(derived, delegate16_DerivedWithPropertyOverride) +} diff --git a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/test/blackbox/FirNativeCodegenBoxTestGenerated.java b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/test/blackbox/FirNativeCodegenBoxTestGenerated.java index 26683b6f71f..e0c83893935 100644 --- a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/test/blackbox/FirNativeCodegenBoxTestGenerated.java +++ b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/test/blackbox/FirNativeCodegenBoxTestGenerated.java @@ -4844,6 +4844,12 @@ public class FirNativeCodegenBoxTestGenerated extends AbstractNativeCodegenBoxTe runTest("compiler/testData/codegen/box/cinterop/kt54284_fmodules.kt"); } + @Test + @TestMetadata("kt57640.kt") + public void testKt57640() throws Exception { + runTest("compiler/testData/codegen/box/cinterop/kt57640.kt"); + } + @Test @TestMetadata("kt63048.kt") public void testKt63048() throws Exception { diff --git a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/test/blackbox/FirNativeCodegenBoxTestNoPLGenerated.java b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/test/blackbox/FirNativeCodegenBoxTestNoPLGenerated.java index 2b1594cbdda..e0de10cce8d 100644 --- a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/test/blackbox/FirNativeCodegenBoxTestNoPLGenerated.java +++ b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/test/blackbox/FirNativeCodegenBoxTestNoPLGenerated.java @@ -4954,6 +4954,12 @@ public class FirNativeCodegenBoxTestNoPLGenerated extends AbstractNativeCodegenB runTest("compiler/testData/codegen/box/cinterop/kt54284_fmodules.kt"); } + @Test + @TestMetadata("kt57640.kt") + public void testKt57640() throws Exception { + runTest("compiler/testData/codegen/box/cinterop/kt57640.kt"); + } + @Test @TestMetadata("kt63048.kt") public void testKt63048() throws Exception { diff --git a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/test/blackbox/NativeCodegenBoxTestGenerated.java b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/test/blackbox/NativeCodegenBoxTestGenerated.java index 2d42c5b979a..37d79331a76 100644 --- a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/test/blackbox/NativeCodegenBoxTestGenerated.java +++ b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/test/blackbox/NativeCodegenBoxTestGenerated.java @@ -4734,6 +4734,12 @@ public class NativeCodegenBoxTestGenerated extends AbstractNativeCodegenBoxTest runTest("compiler/testData/codegen/box/cinterop/kt54284_fmodules.kt"); } + @Test + @TestMetadata("kt57640.kt") + public void testKt57640() throws Exception { + runTest("compiler/testData/codegen/box/cinterop/kt57640.kt"); + } + @Test @TestMetadata("kt63048.kt") public void testKt63048() throws Exception { diff --git a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/test/blackbox/NativeCodegenBoxTestNoPLGenerated.java b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/test/blackbox/NativeCodegenBoxTestNoPLGenerated.java index da7fc54dbb8..7de64cc758c 100644 --- a/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/test/blackbox/NativeCodegenBoxTestNoPLGenerated.java +++ b/native/native.tests/tests-gen/org/jetbrains/kotlin/konan/test/blackbox/NativeCodegenBoxTestNoPLGenerated.java @@ -4845,6 +4845,12 @@ public class NativeCodegenBoxTestNoPLGenerated extends AbstractNativeCodegenBoxT runTest("compiler/testData/codegen/box/cinterop/kt54284_fmodules.kt"); } + @Test + @TestMetadata("kt57640.kt") + public void testKt57640() throws Exception { + runTest("compiler/testData/codegen/box/cinterop/kt57640.kt"); + } + @Test @TestMetadata("kt63048.kt") public void testKt63048() throws Exception {