azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[FIR-TEST] Add new testdata generated after changes in previous commit

Browse Source
This commit is contained in:
Dmitriy Novozhilov
2019-12-11 16:16:22 +03:00
parent e9c02a1cca
commit 2536fa0cd5
4578 changed files with 104067 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/diagnostics/tests/objects/kt21515/annotationConstructor.fir.kt
Vendored
+13
View File
@@ -0,0 +1,13 @@
// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
open class Base {
companion object {
annotation class Foo
}
}
class Derived : Base() {
@Foo
fun foo() = 42
}
compiler/testData/diagnostics/tests/objects/kt21515/callableReferenceComplexCasesWithImportsOld.fir.kt
Vendored
+74
View File
@@ -0,0 +1,74 @@
// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
import A.Base.Companion.FromABaseCompanion
import B.Base.Companion.FromBBaseCompanion
import C.Base.Companion.FromCBaseCompanion
import D.Base.Companion.FromDBaseCompanion
// ===== Case 1: LHS is a class
//
object A {
open class Base {
companion object {
class FromABaseCompanion {
fun foo() = 42
}
}
}
class Derived : Base() {
val a = FromABaseCompanion::foo
}
}
// ===== Case 2: LHS is a class with companion object, function comes from class
object B {
open class Base {
companion object {
class FromBBaseCompanion {
fun foo() = 42
companion object {}
}
}
}
class Derived : Base() {
val a = FromBBaseCompanion::foo
}
}
// ==== Case 3: LHS is a class with companion object, function comes from companion
object C {
open class Base {
companion object {
class FromCBaseCompanion {
companion object {
fun foo() = 42
}
}
}
}
class Derived : Base() {
val a = FromCBaseCompanion::foo
}
}
// ==== Case 4: LHS is an object
object D {
open class Base {
companion object {
object FromDBaseCompanion {
fun foo() = 42
}
}
}
class Derived : Base() {
val a = FromDBaseCompanion::foo
}
}
compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesComplexCasesWithQualificationOld.fir.kt
Vendored
+69
View File
@@ -0,0 +1,69 @@
// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
// ===== Case 1: LHS is a class
//
object A {
open class Base {
companion object {
class FromBaseCompanion {
fun foo() = 42
}
}
}
class Derived : Base() {
val a = A.Base.Companion.FromBaseCompanion::foo
}
}
// ===== Case 2: LHS is a class with companion object, function comes from class
object B {
open class Base {
companion object {
class FromBaseCompanion {
fun foo() = 42
companion object {}
}
}
}
class Derived : Base() {
val a = B.Base.Companion.FromBaseCompanion::foo
}
}
// ==== Case 3: LHS is a class with companion object, function comes from companion
object C {
open class Base {
companion object {
class FromBaseCompanion {
companion object {
fun foo() = 42
}
}
}
}
class Derived : Base() {
val a = C.Base.Companion.FromBaseCompanion::foo
}
}
// ==== Case 4: LHS is an object
object D {
open class Base {
companion object {
object FromBaseCompanion {
fun foo() = 42
}
}
}
class Derived : Base() {
val a = D.Base.Companion.FromBaseCompanion::foo
}
}
compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesNew.fir.kt
Vendored
+142
View File
@@ -0,0 +1,142 @@
// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
// See KT-21515 for a class diagram and details
// class is to prevent accidental short-name import
class O {
open class Alpha {
open fun foo() = 42
class FromAlpha {
fun foo() = 42
}
companion object {
class FromCompanionAlpha {
fun foo() = 42
}
}
}
open class Beta : Alpha() {
override fun foo() = 42
class FromBeta {
fun foo() = 42
}
companion object {
class FromCompanionBeta {
fun foo() = 42
}
}
}
open class A {
open fun foo() = 42
class FromA {
fun foo() = 42
}
companion object : Beta() {
class FromCompanionA {
fun foo() = 42
}
}
}
//////////////////////////
open class FarAway {
open fun foo() = 42
class FromFarAway {
fun foo() = 42
}
}
open class Gamma {
open fun foo() = 42
class FromGamma {
fun foo() = 42
}
companion object : FarAway() {
class FromCompanionGamma {
fun foo() = 42
}
}
}
open class B : A() {
override fun foo() = 42
class FromB {
fun foo() = 42
}
companion object : Gamma() {
override fun foo() = 42
class FromCompanionB {
fun foo() = 42
}
}
}
}
///////////////////////////////
open class Delta {
open fun foo() = 42
class FromDelta {
fun foo() = 42
}
}
class C : O.B() {
override fun foo() = 42
companion object : Delta() {
class FromCompanionC {
fun foo() = 42
}
}
// VISIBLE: Classifiers from direct superclasses
val c = FromA::foo
val d = FromB::foo
// VISIBLE: Classifiers from our own companion
val n = FromCompanionC::foo
// INVISIBLE: direct superclasses themselves.
val a = <!UNRESOLVED_REFERENCE!>A<!>::foo
val b = <!UNRESOLVED_REFERENCE!>A<!>::foo
// DEPRECATED: Classifiers from companions of direct superclasses
val e = FromCompanionA::foo
val f = FromCompanionB::foo
// INVISIBLE: "cousin" supertypes themselves
val g = <!UNRESOLVED_REFERENCE!>Alpha<!>::foo
val h = <!UNRESOLVED_REFERENCE!>Beta<!>::foo
val i = <!UNRESOLVED_REFERENCE!>Gamma<!>::foo
// DEPRECATED: classifiers from "cousin" superclasses
val k = FromAlpha::foo
val l = FromBeta::foo
val m = FromGamma::foo
// INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
val o = <!UNRESOLVED_REFERENCE!>FromCompanionAlpha<!>::foo
val p = <!UNRESOLVED_REFERENCE!>FromCompanionBeta<!>::foo
val q = <!UNRESOLVED_REFERENCE!>FromCompanionGamma<!>::foo
// DEPRECATED: Classifiers from supertypes of our own companion
val r = FromDelta::foo
}
compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOld.fir.kt
Vendored
+142
View File
@@ -0,0 +1,142 @@
// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
// See KT-21515 for a class diagram and details
// class is to prevent accidental short-name import
class O {
open class Alpha {
open fun foo() = 42
class FromAlpha {
fun foo() = 42
}
companion object {
class FromCompanionAlpha {
fun foo() = 42
}
}
}
open class Beta : Alpha() {
override fun foo() = 42
class FromBeta {
fun foo() = 42
}
companion object {
class FromCompanionBeta {
fun foo() = 42
}
}
}
open class A {
open fun foo() = 42
class FromA {
fun foo() = 42
}
companion object : Beta() {
class FromCompanionA {
fun foo() = 42
}
}
}
//////////////////////////
open class FarAway {
open fun foo() = 42
class FromFarAway {
fun foo() = 42
}
}
open class Gamma {
open fun foo() = 42
class FromGamma {
fun foo() = 42
}
companion object : FarAway() {
class FromCompanionGamma {
fun foo() = 42
}
}
}
open class B : A() {
override fun foo() = 42
class FromB {
fun foo() = 42
}
companion object : Gamma() {
override fun foo() = 42
class FromCompanionB {
fun foo() = 42
}
}
}
}
///////////////////////////////
open class Delta {
open fun foo() = 42
class FromDelta {
fun foo() = 42
}
}
class C : O.B() {
override fun foo() = 42
companion object : Delta() {
class FromCompanionC {
fun foo() = 42
}
}
// VISIBLE: Classifiers from direct superclasses
val c = FromA::foo
val d = FromB::foo
// VISIBLE: Classifiers from our own companion
val n = FromCompanionC::foo
// INVISIBLE: direct superclasses themselves.
val a = <!UNRESOLVED_REFERENCE!>A<!>::foo
val b = <!UNRESOLVED_REFERENCE!>A<!>::foo
// DEPRECATED: Classifiers from companions of direct superclasses
val e = FromCompanionA::foo
val f = FromCompanionB::foo
// INVISIBLE: "cousin" supertypes themselves
val g = <!UNRESOLVED_REFERENCE!>Alpha<!>::foo
val h = <!UNRESOLVED_REFERENCE!>Beta<!>::foo
val i = <!UNRESOLVED_REFERENCE!>Gamma<!>::foo
// DEPRECATED: classifiers from "cousin" superclasses
val k = FromAlpha::foo
val l = FromBeta::foo
val m = FromGamma::foo
// INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
val o = <!UNRESOLVED_REFERENCE!>FromCompanionAlpha<!>::foo
val p = <!UNRESOLVED_REFERENCE!>FromCompanionBeta<!>::foo
val q = <!UNRESOLVED_REFERENCE!>FromCompanionGamma<!>::foo
// DEPRECATED: Classifiers from supertypes of our own companion
val r = FromDelta::foo
}
compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOldComplexCases.fir.kt
Vendored
+69
View File
@@ -0,0 +1,69 @@
// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
// ===== Case 1: LHS is a class
//
object A {
open class Base {
companion object {
class FromBaseCompanion {
fun foo() = 42
}
}
}
class Derived : Base() {
val a = FromBaseCompanion::foo
}
}
// ===== Case 2: LHS is a class with companion object, function comes from class
object B {
open class Base {
companion object {
class FromBaseCompanion {
fun foo() = 42
companion object {}
}
}
}
class Derived : Base() {
val a = FromBaseCompanion::foo
}
}
// ==== Case 3: LHS is a class with companion object, function comes from companion
object C {
open class Base {
companion object {
class FromBaseCompanion {
companion object {
fun foo() = 42
}
}
}
}
class Derived : Base() {
val a = FromBaseCompanion::foo
}
}
// ==== Case 4: LHS is an object
object D {
open class Base {
companion object {
object FromBaseCompanion {
fun foo() = 42
}
}
}
class Derived : Base() {
val a = FromBaseCompanion::foo
}
}
compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationNew.fir.kt
Vendored
+142
View File
@@ -0,0 +1,142 @@
// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
// See KT-21515 for a class diagram and details
// class is to prevent accidental short-name import
class O {
open class Alpha {
open fun foo() = 42
class FromAlpha {
fun foo() = 42
}
companion object {
class FromCompanionAlpha {
fun foo() = 42
}
}
}
open class Beta : Alpha() {
override fun foo() = 42
class FromBeta {
fun foo() = 42
}
companion object {
class FromCompanionBeta {
fun foo() = 42
}
}
}
open class A {
open fun foo() = 42
class FromA {
fun foo() = 42
}
companion object : Beta() {
class FromCompanionA {
fun foo() = 42
}
}
}
//////////////////////////
open class FarAway {
open fun foo() = 42
class FromFarAway {
fun foo() = 42
}
}
open class Gamma {
open fun foo() = 42
class FromGamma {
fun foo() = 42
}
companion object : FarAway() {
class FromCompanionGamma {
fun foo() = 42
}
}
}
open class B : A() {
override fun foo() = 42
class FromB {
fun foo() = 42
}
companion object : Gamma() {
override fun foo() = 42
class FromCompanionB {
fun foo() = 42
}
}
}
}
///////////////////////////////
open class Delta {
open fun foo() = 42
class FromDelta {
fun foo() = 42
}
}
class C : O.B() {
override fun foo() = 42
companion object : Delta() {
class FromCompanionC {
fun foo() = 42
}
}
// VISIBLE: Classifiers from direct superclasses
val c = O.A.FromA::foo
val d = O.B.FromB::foo
// VISIBLE: Classifiers from our own companion
val n = C.Companion.FromCompanionC::foo
// INVISIBLE: direct superclasses themselves.
val a = O.A::foo
val b = O.A::foo
// DEPRECATED: Classifiers from companions of direct superclasses
val e = O.A.Companion.FromCompanionA::foo
val f = O.B.Companion.FromCompanionB::foo
// INVISIBLE: "cousin" supertypes themselves
val g = O.Alpha::foo
val h = O.Beta::foo
val i = O.Gamma::foo
// DEPRECATED: classifiers from "cousin" superclasses
val k = O.Alpha.FromAlpha::foo
val l = O.Beta.FromBeta::foo
val m = O.Gamma.FromGamma::foo
// INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
val o = O.Alpha.Companion.FromCompanionAlpha::foo
val p = O.Beta.Companion.FromCompanionBeta::foo
val q = O.Gamma.Companion.FromCompanionGamma::foo
// DEPRECATED: Classifiers from supertypes of our own companion
val r = Delta.FromDelta::foo
}
compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationOld.fir.kt
Vendored
+142
View File
@@ -0,0 +1,142 @@
// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
// See KT-21515 for a class diagram and details
// class is to prevent accidental short-name import
class O {
open class Alpha {
open fun foo() = 42
class FromAlpha {
fun foo() = 42
}
companion object {
class FromCompanionAlpha {
fun foo() = 42
}
}
}
open class Beta : Alpha() {
override fun foo() = 42
class FromBeta {
fun foo() = 42
}
companion object {
class FromCompanionBeta {
fun foo() = 42
}
}
}
open class A {
open fun foo() = 42
class FromA {
fun foo() = 42
}
companion object : Beta() {
class FromCompanionA {
fun foo() = 42
}
}
}
//////////////////////////
open class FarAway {
open fun foo() = 42
class FromFarAway {
fun foo() = 42
}
}
open class Gamma {
open fun foo() = 42
class FromGamma {
fun foo() = 42
}
companion object : FarAway() {
class FromCompanionGamma {
fun foo() = 42
}
}
}
open class B : A() {
override fun foo() = 42
class FromB {
fun foo() = 42
}
companion object : Gamma() {
override fun foo() = 42
class FromCompanionB {
fun foo() = 42
}
}
}
}
///////////////////////////////
open class Delta {
open fun foo() = 42
class FromDelta {
fun foo() = 42
}
}
class C : O.B() {
override fun foo() = 42
companion object : Delta() {
class FromCompanionC {
fun foo() = 42
}
}
// VISIBLE: Classifiers from direct superclasses
val c = O.A.FromA::foo
val d = O.B.FromB::foo
// VISIBLE: Classifiers from our own companion
val n = FromCompanionC::foo
// INVISIBLE: direct superclasses themselves.
val a = O.A::foo
val b = O.A::foo
// DEPRECATED: Classifiers from companions of direct superclasses
val e = O.A.Companion.FromCompanionA::foo
val f = O.B.Companion.FromCompanionB::foo
// INVISIBLE: "cousin" supertypes themselves
val g = O.Alpha::foo
val h = O.Beta::foo
val i = O.Gamma::foo
// DEPRECATED: classifiers from "cousin" superclasses
val k = O.Alpha.FromAlpha::foo
val l = O.Beta.FromBeta::foo
val m = O.Gamma.FromGamma::foo
// INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
val o = O.Alpha.Companion.FromCompanionAlpha::foo
val p = O.Beta.Companion.FromCompanionBeta::foo
val q = O.Gamma.Companion.FromCompanionGamma::foo
// DEPRECATED: Classifiers from supertypes of our own companion
val r = Delta.FromDelta::foo
}
compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectNew.fir.kt
Vendored
+99
View File
@@ -0,0 +1,99 @@
// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
// See KT-21515 for a class diagram and details
// Object is to prevent accidental short-name import
object O {
open class Alpha {
class FromAlpha
companion object {
class FromCompanionAlpha
}
}
open class Beta : Alpha() {
class FromBeta
companion object {
class FromCompanionBeta
}
}
open class A {
class FromA
companion object : Beta() {
class FromCompanionA
}
}
//////////////////////////
open class FarAway {
class FromFarAway
}
open class Gamma {
class FromGamma
companion object : FarAway() {
class FromCompanionGamma
}
}
open class B : A() {
class FromB
companion object : Gamma() {
class FromCompanionB
}
}
}
///////////////////////////////
open class Delta {
class FromDelta
}
class C : O.B() {
companion object : Delta() {
class FromCompanionC
}
// VISIBLE: Classifiers from direct superclasses
val c: FromA? = null
val d: FromB? = null
// VISIBLE: Classifiers from our own companion
val n: FromCompanionC? = null
// INVISIBLE: direct superclasses themselves.
val a: A? = null
val b: B? = null
// DEPRECATED: Classifiers from companions of direct superclasses
val e: FromCompanionA? = null
val f: FromCompanionB? = null
// INVISIBLE: "cousin" supertypes themselves
val g: Alpha? = null
val h: Beta? = null
val i: Gamma? = null
// DEPRECATED: classifiers from "cousin" superclasses
val k: FromAlpha? = null
val l: FromBeta? = null
val m: FromGamma? = null
// INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
val o: FromCompanionAlpha? = null
val p: FromCompanionBeta? = null
val q: FromCompanionGamma? = null
// DEPRECATED: Classifiers from supertypes of our own companion
val r: FromDelta? = null
}
compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectOld.fir.kt
Vendored
+98
View File
@@ -0,0 +1,98 @@
// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
// See KT-21515 for a class diagram and details
// Object is to prevent accidental short-name import
object O {
open class Alpha {
class FromAlpha
companion object {
class FromCompanionAlpha
}
}
open class Beta : Alpha() {
class FromBeta
companion object {
class FromCompanionBeta
}
}
open class A {
class FromA
companion object : Beta() {
class FromCompanionA
}
}
//////////////////////////
open class FarAway {
class FromFarAway
}
open class Gamma {
class FromGamma
companion object : FarAway() {
class FromCompanionGamma
}
}
open class B : A() {
class FromB
companion object : Gamma() {
class FromCompanionB
}
}
}
///////////////////////////////
open class Delta {
class FromDelta
}
class C : O.B() {
companion object : Delta() {
class FromCompanionC
}
// VISIBLE: Classifiers from direct superclasses
val c: FromA? = null
val d: FromB? = null
// VISIBLE: Classifiers from our own companion
val n: FromCompanionC? = null
// INVISIBLE: direct superclasses themselves.
val a: A? = null
val b: B? = null
// DEPRECATED: Classifiers from companions of direct superclasses
val e: FromCompanionA? = null
val f: FromCompanionB? = null
// INVISIBLE: "cousin" supertypes themselves
val g: Alpha? = null
val h: Beta? = null
val i: Gamma? = null
// DEPRECATED: classifiers from "cousin" superclasses
val k: FromAlpha? = null
val l: FromBeta? = null
val m: FromGamma? = null
// INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
val o: FromCompanionAlpha? = null
val p: FromCompanionBeta? = null
val q: FromCompanionGamma? = null
// DEPRECATED: Classifiers from supertypes of our own companion
val r: FromDelta? = null
}
compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationNew.fir.kt
Vendored
+99
View File
@@ -0,0 +1,99 @@
// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
// See KT-21515 for a class diagram and details
// Object is to prevent accidental short-name import
object O {
open class Alpha {
class FromAlpha
companion object {
class FromCompanionAlpha
}
}
open class Beta : Alpha() {
class FromBeta
companion object {
class FromCompanionBeta
}
}
open class A {
class FromA
companion object : Beta() {
class FromCompanionA
}
}
//////////////////////////
open class FarAway {
class FromFarAway
}
open class Gamma {
class FromGamma
companion object : FarAway() {
class FromCompanionGamma
}
}
open class B : A() {
class FromB
companion object : Gamma() {
class FromCompanionB
}
}
}
///////////////////////////////
open class Delta {
class FromDelta
}
class C : O.B() {
companion object : Delta() {
class FromCompanionC
}
// VISIBLE: Classifiers from direct superclasses
val c: O.A.FromA? = null
val d: O.B.FromB? = null
// VISIBLE: Classifiers from our own companion
val n: C.Companion.FromCompanionC? = null
// INVISIBLE: direct superclasses themselves.
val a: O.A? = null
val b: O.B? = null
// DEPRECATED: Classifiers from companions of direct superclasses
val e: O.A.Companion.FromCompanionA? = null
val f: O.B.Companion.FromCompanionB? = null
// INVISIBLE: "cousin" supertypes themselves
val g: O.Alpha? = null
val h: O.Beta? = null
val i: O.Gamma? = null
// DEPRECATED: classifiers from "cousin" superclasses
val k: O.Alpha.FromAlpha? = null
val l: O.Beta.FromBeta? = null
val m: O.Gamma.FromGamma? = null
// INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
val o: O.Alpha.Companion.FromCompanionAlpha? = null
val p: O.Beta.Companion.FromCompanionBeta? = null
val q: O.Gamma.Companion.FromCompanionGamma? = null
// DEPRECATED: Classifiers from supertypes of our own companion
val r: Delta.FromDelta? = null
}
compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationOld.fir.kt
Vendored
+98
View File
@@ -0,0 +1,98 @@
// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
// See KT-21515 for a class diagram and details
// Object is to prevent accidental short-name import
object O {
open class Alpha {
class FromAlpha
companion object {
class FromCompanionAlpha
}
}
open class Beta : Alpha() {
class FromBeta
companion object {
class FromCompanionBeta
}
}
open class A {
class FromA
companion object : Beta() {
class FromCompanionA
}
}
//////////////////////////
open class FarAway {
class FromFarAway
}
open class Gamma {
class FromGamma
companion object : FarAway() {
class FromCompanionGamma
}
}
open class B : A() {
class FromB
companion object : Gamma() {
class FromCompanionB
}
}
}
///////////////////////////////
open class Delta {
class FromDelta
}
class C : O.B() {
companion object : Delta() {
class FromCompanionC
}
// VISIBLE: Classifiers from direct superclasses
val c: O.A.FromA? = null
val d: O.B.FromB? = null
// VISIBLE: Classifiers from our own companion
val n: C.Companion.FromCompanionC? = null
// INVISIBLE: direct superclasses themselves.
val a: O.A? = null
val b: O.B? = null
// DEPRECATED: Classifiers from companions of direct superclasses
val e: O.A.Companion.FromCompanionA? = null
val f: O.B.Companion.FromCompanionB? = null
// INVISIBLE: "cousin" supertypes themselves
val g: O.Alpha? = null
val h: O.Beta? = null
val i: O.Gamma? = null
// DEPRECATED: classifiers from "cousin" superclasses
val k: O.Alpha.FromAlpha? = null
val l: O.Beta.FromBeta? = null
val m: O.Gamma.FromGamma? = null
// INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
val o: O.Alpha.Companion.FromCompanionAlpha? = null
val p: O.Beta.Companion.FromCompanionBeta? = null
val q: O.Gamma.Companion.FromCompanionGamma? = null
// DEPRECATED: Classifiers from supertypes of our own companion
val r: Delta.FromDelta? = null
}
compiler/testData/diagnostics/tests/objects/kt21515/classifierIsVisibleByTwoPaths.fir.kt
Vendored
+17
View File
@@ -0,0 +1,17 @@
open class A {
class FromA {
fun foo() = 42
}
}
class B : A() {
companion object : A() { }
// we're seeing FromA here by two paths: one is deprecated (via companion object), and another one is not,
// so we shouldn't see deprecation warning
val a: FromA? = null
val b = FromA::foo
val c = FromA()
}
compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedNew.fir.kt
Vendored
+100
View File
@@ -0,0 +1,100 @@
// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
// !DIAGNOSTICS: -UNUSED_VARIABLE
// See KT-21515 for a open class diagram and details
// Object is to prevent accidental short-name import
object O {
open class Alpha {
open class FromAlpha
companion object {
open class FromCompanionAlpha
}
}
open class Beta : Alpha() {
open class FromBeta
companion object {
open class FromCompanionBeta
}
}
open class A {
open class FromA
companion object : Beta() {
open class FromCompanionA
}
}
//////////////////////////
open class FarAway {
open class FromFarAway
}
open class Gamma {
open class FromGamma
companion object : FarAway() {
open class FromCompanionGamma
}
}
open class B : A() {
open class FromB
companion object : Gamma() {
open class FromCompanionB
}
}
}
///////////////////////////////
open class Delta {
open class FromDelta
}
open class C : O.B() {
companion object : Delta() {
open class FromCompanionC
}
// VISIBLE: Classifiers from direct superclasses
open class c : FromA()
open class d : FromB()
// VISIBLE: Classifiers from our own companion
open class n : FromCompanionC()
// INVISIBLE: direct superclasses themselves.
open class a : A()
open class b : B()
// DEPRECATED: Classifiers from companions of direct superclasses
open class e : FromCompanionA()
open class f : FromCompanionB()
// INVISIBLE: "cousin" supertypes themselves
open class g : Alpha()
open class h : Beta()
open class i : Gamma()
// DEPRECATED: classifiers from "cousin" superclasses
open class k : FromAlpha()
open class l : FromBeta()
open class m : FromGamma()
// INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
open class o : FromCompanionAlpha()
open class p : FromCompanionBeta()
open class q : FromCompanionGamma()
// DEPRECATED: Classifiers from supertypes of our own companion
open class r : FromDelta()
}
compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedOld.fir.kt
Vendored
+100
View File
@@ -0,0 +1,100 @@
// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
// !DIAGNOSTICS: -UNUSED_VARIABLE
// See KT-21515 for a open class diagram and details
// Object is to prevent accidental short-name import
object O {
open class Alpha {
open class FromAlpha
companion object {
open class FromCompanionAlpha
}
}
open class Beta : Alpha() {
open class FromBeta
companion object {
open class FromCompanionBeta
}
}
open class A {
open class FromA
companion object : Beta() {
open class FromCompanionA
}
}
//////////////////////////
open class FarAway {
open class FromFarAway
}
open class Gamma {
open class FromGamma
companion object : FarAway() {
open class FromCompanionGamma
}
}
open class B : A() {
open class FromB
companion object : Gamma() {
open class FromCompanionB
}
}
}
///////////////////////////////
open class Delta {
open class FromDelta
}
open class C : O.B() {
companion object : Delta() {
open class FromCompanionC
}
// VISIBLE: Classifiers from direct superclasses
open class c : FromA()
open class d : FromB()
// VISIBLE: Classifiers from our own companion
open class n : FromCompanionC()
// INVISIBLE: direct superclasses themselves.
open class a : A()
open class b : B()
// DEPRECATED: Classifiers from companions of direct superclasses
open class e : FromCompanionA()
open class f : FromCompanionB()
// INVISIBLE: "cousin" supertypes themselves
open class g : Alpha()
open class h : Beta()
open class i : Gamma()
// DEPRECATED: classifiers from "cousin" superclasses
open class k : FromAlpha()
open class l : FromBeta()
open class m : FromGamma()
// INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
open class o : FromCompanionAlpha()
open class p : FromCompanionBeta()
open class q : FromCompanionGamma()
// DEPRECATED: Classifiers from supertypes of our own companion
open class r : FromDelta()
}
compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationNew.fir.kt
Vendored
+100
View File
@@ -0,0 +1,100 @@
// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
// !DIAGNOSTICS: -UNUSED_VARIABLE
// See KT-21515 for a open class diagram and details
// Object is to prevent accidental short-name import
object O {
open class Alpha {
open class FromAlpha
companion object {
open class FromCompanionAlpha
}
}
open class Beta : Alpha() {
open class FromBeta
companion object {
open class FromCompanionBeta
}
}
open class A {
open class FromA
companion object : Beta() {
open class FromCompanionA
}
}
//////////////////////////
open class FarAway {
open class FromFarAway
}
open class Gamma {
open class FromGamma
companion object : FarAway() {
open class FromCompanionGamma
}
}
open class B : A() {
open class FromB
companion object : Gamma() {
open class FromCompanionB
}
}
}
///////////////////////////////
open class Delta {
open class FromDelta
}
open class C : O.B() {
companion object : Delta() {
open class FromCompanionC
}
// VISIBLE: Classifiers from direct superclasses
open class c : O.A.FromA()
open class d : O.B.FromB()
// VISIBLE: Classifiers from our own companion
open class n : C.Companion.FromCompanionC()
// INVISIBLE: direct superclasses themselves.
open class a : O.A()
open class b : O.B()
// DEPRECATED: Classifiers from companions of direct superclasses
open class e : O.A.Companion.FromCompanionA()
open class f : O.B.Companion.FromCompanionB()
// INVISIBLE: "cousin" supertypes themselves
open class g : O.Alpha()
open class h : O.Beta()
open class i : O.Gamma()
// DEPRECATED: classifiers from "cousin" superclasses
open class k : O.Alpha.FromAlpha()
open class l : O.Beta.FromBeta()
open class m : O.Gamma.FromGamma()
// INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
open class o : O.Alpha.Companion.FromCompanionAlpha()
open class p : O.Beta.Companion.FromCompanionBeta()
open class q : O.Gamma.Companion.FromCompanionGamma()
// DEPRECATED: Classifiers from supertypes of our own companion
open class r : Delta.FromDelta()
}
compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationOld.fir.kt
Vendored
+100
View File
@@ -0,0 +1,100 @@
// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
// !DIAGNOSTICS: -UNUSED_VARIABLE
// See KT-21515 for a open class diagram and details
// Object is to prevent accidental short-name import
object O {
open class Alpha {
open class FromAlpha
companion object {
open class FromCompanionAlpha
}
}
open class Beta : Alpha() {
open class FromBeta
companion object {
open class FromCompanionBeta
}
}
open class A {
open class FromA
companion object : Beta() {
open class FromCompanionA
}
}
//////////////////////////
open class FarAway {
open class FromFarAway
}
open class Gamma {
open class FromGamma
companion object : FarAway() {
open class FromCompanionGamma
}
}
open class B : A() {
open class FromB
companion object : Gamma() {
open class FromCompanionB
}
}
}
///////////////////////////////
open class Delta {
open class FromDelta
}
open class C : O.B() {
companion object : Delta() {
open class FromCompanionC
}
// VISIBLE: Classifiers from direct superclasses
open class c : O.A.FromA()
open class d : O.B.FromB()
// VISIBLE: Classifiers from our own companion
open class n : C.Companion.FromCompanionC()
// INVISIBLE: direct superclasses themselves.
open class a : O.A()
open class b : O.B()
// DEPRECATED: Classifiers from companions of direct superclasses
open class e : O.A.Companion.FromCompanionA()
open class f : O.B.Companion.FromCompanionB()
// INVISIBLE: "cousin" supertypes themselves
open class g : O.Alpha()
open class h : O.Beta()
open class i : O.Gamma()
// DEPRECATED: classifiers from "cousin" superclasses
open class k : O.Alpha.FromAlpha()
open class l : O.Beta.FromBeta()
open class m : O.Gamma.FromGamma()
// INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
open class o : O.Alpha.Companion.FromCompanionAlpha()
open class p : O.Beta.Companion.FromCompanionBeta()
open class q : O.Gamma.Companion.FromCompanionGamma()
// DEPRECATED: Classifiers from supertypes of our own companion
open class r : Delta.FromDelta()
}
compiler/testData/diagnostics/tests/objects/kt21515/staticsFromJavaNew.fir.kt
Vendored
+48
View File
@@ -0,0 +1,48 @@
// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
// FILE: test/Java.java
package test;
public class Java {
public static void method() { }
public static int property = 42;
public static class Classifier { }
public static void syntheticSam(Runnable r) { }
public static int getStaticSyntheticProperty() { return 42; }
public static int setStaticSyntheticProperty(int x) { return 42; }
public int getInstanceSyntheticProperty() { return 42; }
public int setInstanceSyntheticProperty(int x) { return 42; }
}
// FILE: Kotlin.kt
package test
open class Base {
companion object : Java() {
}
}
class Derived : Base() {
fun test(javaStaticInTypePosition: Classifier) {
<!UNRESOLVED_REFERENCE!>method<!>()
<!UNRESOLVED_REFERENCE!>property<!>
Classifier()
<!UNRESOLVED_REFERENCE!>syntheticSam<!> { }
// Instance members shouldn't be affected, but we check them, just in case
val y = <!UNRESOLVED_REFERENCE!>instanceSyntheticProperty<!>
<!UNRESOLVED_REFERENCE!>instanceSyntheticProperty<!> = 43
// Note that statics actually aren't converted into synthetic property in Kotlin
val x = <!UNRESOLVED_REFERENCE!>syntheticProperty<!>
<!UNRESOLVED_REFERENCE!>syntheticProperty<!> = 42
}
class JavaStaticInSupertypeList : Classifier() {
}
}
compiler/testData/diagnostics/tests/objects/kt21515/staticsFromJavaOld.fir.kt
Vendored
+48
View File
@@ -0,0 +1,48 @@
// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
// FILE: test/Java.java
package test;
public class Java {
public static void method() { }
public static int property = 42;
public static class Classifier { }
public static void syntheticSam(Runnable r) { }
public static int getStaticSyntheticProperty() { return 42; }
public static int setStaticSyntheticProperty(int x) { return 42; }
public int getInstanceSyntheticProperty() { return 42; }
public int setInstanceSyntheticProperty(int x) { return 42; }
}
// FILE: Kotlin.kt
package test
open class Base {
companion object : Java() {
}
}
class Derived : Base() {
fun test(javaStaticInTypePosition: Classifier) {
<!UNRESOLVED_REFERENCE!>method<!>()
<!UNRESOLVED_REFERENCE!>property<!>
Classifier()
<!UNRESOLVED_REFERENCE!>syntheticSam<!> { }
// Instance members shouldn't be affected, but we check them, just in case
val y = <!UNRESOLVED_REFERENCE!>instanceSyntheticProperty<!>
<!UNRESOLVED_REFERENCE!>instanceSyntheticProperty<!> = 43
// Note that statics actually aren't converted into synthetic property in Kotlin
val x = <!UNRESOLVED_REFERENCE!>syntheticProperty<!>
<!UNRESOLVED_REFERENCE!>syntheticProperty<!> = 42
}
class JavaStaticInSupertypeList : Classifier() {
}
}
compiler/testData/diagnostics/tests/objects/kt21515/staticsFromJavaWithQualificationNew.fir.kt
Vendored
+53
View File
@@ -0,0 +1,53 @@
// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
// FILE: test/Java.java
package test;
public class Java {
public static void method() { }
public static int property = 42;
public static class Classifier { }
public static void syntheticSam(Runnable r) { }
public static int getStaticSyntheticProperty() { return 42; }
public static int setStaticSyntheticProperty(int x) { return 42; }
public int getInstanceSyntheticProperty() { return 42; }
public int setInstanceSyntheticProperty(int x) { return 42; }
}
// FILE: Kotlin.kt
package test
import test.Java.method
import test.Java.Classifier
import test.Java.property
import test.Java.syntheticSam
open class Base {
companion object : Java() {
}
}
class Derived : Base() {
fun test(javaStaticInTypePosition: Classifier) {
method()
property
Classifier()
syntheticSam { }
// Instance members shouldn't be affected, but we check them, just in case
val y = <!UNRESOLVED_REFERENCE!>instanceSyntheticProperty<!>
<!UNRESOLVED_REFERENCE!>instanceSyntheticProperty<!> = 43
// Note that statics actually aren't converted into synthetic property in Kotlin
val x = <!UNRESOLVED_REFERENCE!>syntheticProperty<!>
<!UNRESOLVED_REFERENCE!>syntheticProperty<!> = 42
}
class JavaStaticInSupertypeList : Classifier() {
}
}
compiler/testData/diagnostics/tests/objects/kt21515/staticsFromJavaWithQualificationOld.fir.kt
Vendored
+53
View File
@@ -0,0 +1,53 @@
// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
// FILE: test/Java.java
package test;
public class Java {
public static void method() { }
public static int property = 42;
public static class Classifier { }
public static void syntheticSam(Runnable r) { }
public static int getStaticSyntheticProperty() { return 42; }
public static int setStaticSyntheticProperty(int x) { return 42; }
public int getInstanceSyntheticProperty() { return 42; }
public int setInstanceSyntheticProperty(int x) { return 42; }
}
// FILE: Kotlin.kt
package test
import test.Java.method
import test.Java.Classifier
import test.Java.property
import test.Java.syntheticSam
open class Base {
companion object : Java() {
}
}
class Derived : Base() {
fun test(javaStaticInTypePosition: Classifier) {
method()
property
Classifier()
syntheticSam { }
// Instance members shouldn't be affected, but we check them, just in case
val y = <!UNRESOLVED_REFERENCE!>instanceSyntheticProperty<!>
<!UNRESOLVED_REFERENCE!>instanceSyntheticProperty<!> = 43
// Note that statics actually aren't converted into synthetic property in Kotlin
val x = <!UNRESOLVED_REFERENCE!>syntheticProperty<!>
<!UNRESOLVED_REFERENCE!>syntheticProperty<!> = 42
}
class JavaStaticInSupertypeList : Classifier() {
}
}
compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorNew.fir.kt
Vendored
+100
View File
@@ -0,0 +1,100 @@
// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
// !DIAGNOSTICS: -UNUSED_VARIABLE
// See KT-21515 for a class diagram and details
// Object is to prevent accidental short-name import
object O {
open class Alpha {
class FromAlpha
companion object {
class FromCompanionAlpha
}
}
open class Beta : Alpha() {
class FromBeta
companion object {
class FromCompanionBeta
}
}
open class A {
class FromA
companion object : Beta() {
class FromCompanionA
}
}
//////////////////////////
open class FarAway {
class FromFarAway
}
open class Gamma {
class FromGamma
companion object : FarAway() {
class FromCompanionGamma
}
}
open class B : A() {
class FromB
companion object : Gamma() {
class FromCompanionB
}
}
}
///////////////////////////////
open class Delta {
class FromDelta
}
class C : O.B() {
companion object : Delta() {
class FromCompanionC
}
// VISIBLE: Classifiers from direct superclasses
val c = FromA()
val d = FromB()
// VISIBLE: Classifiers from our own companion
val n = FromCompanionC()
// INVISIBLE: direct superclasses themselves.
val a = <!UNRESOLVED_REFERENCE!>A<!>()
val b = <!UNRESOLVED_REFERENCE!>B<!>()
// DEPRECATED: Classifiers from companions of direct superclasses
val e = FromCompanionA()
val f = FromCompanionB()
// INVISIBLE: "cousin" supertypes themselves
val g = <!UNRESOLVED_REFERENCE!>Alpha<!>()
val h = <!UNRESOLVED_REFERENCE!>Beta<!>()
val i = <!UNRESOLVED_REFERENCE!>Gamma<!>()
// DEPRECATED: classifiers from "cousin" superclasses
val k = FromAlpha()
val l = FromBeta()
val m = FromGamma()
// INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
val o = <!UNRESOLVED_REFERENCE!>FromCompanionAlpha<!>()
val p = <!UNRESOLVED_REFERENCE!>FromCompanionBeta<!>()
val q = <!UNRESOLVED_REFERENCE!>FromCompanionGamma<!>()
// DEPRECATED: Classifiers from supertypes of our own companion
val r = FromDelta()
}
compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorOld.fir.kt
Vendored
+99
View File
@@ -0,0 +1,99 @@
// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
// !DIAGNOSTICS: -UNUSED_VARIABLE
// See KT-21515 for a class diagram and details
// Object is to prevent accidental short-name import
object O {
open class Alpha {
class FromAlpha
companion object {
class FromCompanionAlpha
}
}
open class Beta : Alpha() {
class FromBeta
companion object {
class FromCompanionBeta
}
}
open class A {
class FromA
companion object : Beta() {
class FromCompanionA
}
}
//////////////////////////
open class FarAway {
class FromFarAway
}
open class Gamma {
class FromGamma
companion object : FarAway() {
class FromCompanionGamma
}
}
open class B : A() {
class FromB
companion object : Gamma() {
class FromCompanionB
}
}
}
///////////////////////////////
open class Delta {
class FromDelta
}
class C : O.B() {
companion object : Delta() {
class FromCompanionC
}
// VISIBLE: Classifiers from direct superclasses
val c = FromA()
val d = FromB()
// VISIBLE: Classifiers from our own companion
val n = FromCompanionC()
// INVISIBLE: direct superclasses themselves.
val a = <!UNRESOLVED_REFERENCE!>A<!>()
val b = <!UNRESOLVED_REFERENCE!>B<!>()
// DEPRECATED: Classifiers from companions of direct superclasses
val e = FromCompanionA()
val f = FromCompanionB()
// INVISIBLE: "cousin" supertypes themselves
val g = <!UNRESOLVED_REFERENCE!>Alpha<!>()
val h = <!UNRESOLVED_REFERENCE!>Beta<!>()
val i = <!UNRESOLVED_REFERENCE!>Gamma<!>()
// DEPRECATED: classifiers from "cousin" superclasses
val k = FromAlpha()
val l = FromBeta()
val m = FromGamma()
// INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
val o = <!UNRESOLVED_REFERENCE!>FromCompanionAlpha<!>()
val p = <!UNRESOLVED_REFERENCE!>FromCompanionBeta<!>()
val q = <!UNRESOLVED_REFERENCE!>FromCompanionGamma<!>()
// DEPRECATED: Classifiers from supertypes of our own companion
val r = FromDelta()
}
compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationNew.fir.kt
Vendored
+100
View File
@@ -0,0 +1,100 @@
// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
// !DIAGNOSTICS: -UNUSED_VARIABLE
// See KT-21515 for a class diagram and details
// Object is to prevent accidental short-name import
object O {
open class Alpha {
class FromAlpha
companion object {
class FromCompanionAlpha
}
}
open class Beta : Alpha() {
class FromBeta
companion object {
class FromCompanionBeta
}
}
open class A {
class FromA
companion object : Beta() {
class FromCompanionA
}
}
//////////////////////////
open class FarAway {
class FromFarAway
}
open class Gamma {
class FromGamma
companion object : FarAway() {
class FromCompanionGamma
}
}
open class B : A() {
class FromB
companion object : Gamma() {
class FromCompanionB
}
}
}
///////////////////////////////
open class Delta {
class FromDelta
}
class C : O.B() {
companion object : Delta() {
class FromCompanionC
}
// VISIBLE: Classifiers from direct superclasses
val c = O.A.FromA()
val d = O.B.FromB()
// VISIBLE: Classifiers from our own companion
val n = C.Companion.FromCompanionC()
// INVISIBLE: direct superclasses themselves.
val a = O.A()
val b = O.B()
// DEPRECATED: Classifiers from companions of direct superclasses
val e = O.A.Companion.FromCompanionA()
val f = O.B.Companion.FromCompanionB()
// INVISIBLE: "cousin" supertypes themselves
val g = O.Alpha()
val h = O.Beta()
val i = O.Gamma()
// DEPRECATED: classifiers from "cousin" superclasses
val k = O.Alpha.FromAlpha()
val l = O.Beta.FromBeta()
val m = O.Gamma.FromGamma()
// INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
val o = O.Alpha.Companion.FromCompanionAlpha()
val p = O.Beta.Companion.FromCompanionBeta()
val q = O.Gamma.Companion.FromCompanionGamma()
// DEPRECATED: Classifiers from supertypes of our own companion
val r = Delta.FromDelta()
}
compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationOld.fir.kt
Vendored
+100
View File
@@ -0,0 +1,100 @@
// !LANGUAGE: -ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
// !DIAGNOSTICS: -UNUSED_VARIABLE
// See KT-21515 for a class diagram and details
// Object is to prevent accidental short-name import
object O {
open class Alpha {
class FromAlpha
companion object {
class FromCompanionAlpha
}
}
open class Beta : Alpha() {
class FromBeta
companion object {
class FromCompanionBeta
}
}
open class A {
class FromA
companion object : Beta() {
class FromCompanionA
}
}
//////////////////////////
open class FarAway {
class FromFarAway
}
open class Gamma {
class FromGamma
companion object : FarAway() {
class FromCompanionGamma
}
}
open class B : A() {
class FromB
companion object : Gamma() {
class FromCompanionB
}
}
}
///////////////////////////////
open class Delta {
class FromDelta
}
class C : O.B() {
companion object : Delta() {
class FromCompanionC
}
// VISIBLE: Classifiers from direct superclasses
val c = O.A.FromA()
val d = O.B.FromB()
// VISIBLE: Classifiers from our own companion
val n = C.Companion.FromCompanionC()
// INVISIBLE: direct superclasses themselves.
val a = O.A()
val b = O.B()
// DEPRECATED: Classifiers from companions of direct superclasses
val e = O.A.Companion.FromCompanionA()
val f = O.B.Companion.FromCompanionB()
// INVISIBLE: "cousin" supertypes themselves
val g = O.Alpha()
val h = O.Beta()
val i = O.Gamma()
// DEPRECATED: classifiers from "cousin" superclasses
val k = O.Alpha.FromAlpha()
val l = O.Beta.FromBeta()
val m = O.Gamma.FromGamma()
// INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
val o = O.Alpha.Companion.FromCompanionAlpha()
val p = O.Beta.Companion.FromCompanionBeta()
val q = O.Gamma.Companion.FromCompanionGamma()
// DEPRECATED: Classifiers from supertypes of our own companion
val r = Delta.FromDelta()
}