[FIR] Fix effective visibility calculation & relevant test data

2020-04-14 14:08:28 +03:00
parent d811f6f4a6
commit 6d63de01ac
34 changed files with 137 additions and 99 deletions
@@ -7,4 +7,4 @@ enum class E {
 fun foo() = E.values()
 fun bar() = E.valueOf("ENTRY")
 fun baz() = E.ENTRY
-fun quux() = E
+<!EXPOSED_FUNCTION_RETURN_TYPE!>fun quux() = E<!>
@@ -3,10 +3,10 @@ internal class My
 class Your

 // Both arguments should be exposed
-fun foo(my: My, f: (My) -> Unit) = f(my)
+fun foo(<!EXPOSED_PARAMETER_TYPE!>my: My<!>, <!EXPOSED_PARAMETER_TYPE!>f: (My) -> Unit<!>) = f(my)

 // Ok
 fun bar(your: Your, f: (Your) -> Unit) = f(your)

 // Exposed, returns My
-fun gav(f: () -> My) = f()
+<!EXPOSED_FUNCTION_RETURN_TYPE!>fun gav(<!EXPOSED_PARAMETER_TYPE!>f: () -> My<!>) = f()<!>
@@ -10,13 +10,13 @@ internal open class Your: My() {
 open class His: Your() {
    protected open class Nested
    // error, public from internal
-    val x = My()
+    <!EXPOSED_PROPERTY_TYPE!>val x = My()<!>
    // valid, private from internal
    private fun bar() = My()
    // valid, internal from internal
    internal var y: My? = null
    // error, protected from internal
-    protected fun baz() = Your()
+    <!EXPOSED_FUNCTION_RETURN_TYPE!>protected fun baz() = Your()<!>
 }

 internal class Their: His() {
@@ -3,8 +3,8 @@ interface Your
 class My {
    internal val x = object : Your {}

-    internal fun foo() = {
+    <!EXPOSED_FUNCTION_RETURN_TYPE!>internal fun foo() = {
        class Local
        Local()
-    }()
+    }()<!>
 }
@@ -1,14 +1,14 @@
 // invalid, depends on local class
-fun foo() = run {
+<!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo() = run {
    class A
    A()
-}
+}<!>

 // invalid, depends on local class
-fun gav() = {
+<!EXPOSED_FUNCTION_RETURN_TYPE!>fun gav() = {
    class B
    B()
-}
+}<!>

 abstract class My

@@ -2,27 +2,27 @@ class My<T>(val value: T)

 open class Base

-fun invalid1() = run {
+<!EXPOSED_FUNCTION_RETURN_TYPE!>fun invalid1() = run {
    class Local
    My(Local())
-}
+}<!>

 fun invalid2() = My(object {})

 fun invalid3() = My(object : Base() {})

-fun invalid4() = run {
+<!EXPOSED_FUNCTION_RETURN_TYPE!>fun invalid4() = run {
    class Local
    My(My(Local()))
-}
+}<!>

-fun invalid5() = run {
+<!EXPOSED_FUNCTION_RETURN_TYPE!>fun invalid5() = run {
    fun invalid5a() = run {
        class Local
        Local()
    }
    My(invalid5a())
-}
+}<!>

 // Valid: effectively Any
 fun valid1() = object {}
@@ -4,9 +4,9 @@ class Something {
    internal val internalVal1 = object { override fun toString() = "!" }
    private val privateVal1 = object { override fun toString() = "!" }

-    public val publicVal2 = run { class A; A() }
-    protected val protectedVal2 = run { class A; A() }
-    internal val internalVal2 = run { class A; A() }
+    <!EXPOSED_PROPERTY_TYPE!>public val publicVal2 = run { class A; A() }<!>
+    <!EXPOSED_PROPERTY_TYPE!>protected val protectedVal2 = run { class A; A() }<!>
+    <!EXPOSED_PROPERTY_TYPE!>internal val internalVal2 = run { class A; A() }<!>
    private val privateVal2 = run { class A; A() }

    public fun publicFun1() = object { override fun toString() = "!" }
@@ -14,8 +14,8 @@ class Something {
    internal fun internalFun1() = object { override fun toString() = "!" }
    private fun privateFun1() = object { override fun toString() = "!" }

-    public fun publicFun2() = run { class A; A() }
-    protected fun protectedFun2() = run { class A; A() }
-    internal fun internalFun2() = run { class A; A() }
+    <!EXPOSED_FUNCTION_RETURN_TYPE!>public fun publicFun2() = run { class A; A() }<!>
+    <!EXPOSED_FUNCTION_RETURN_TYPE!>protected fun protectedFun2() = run { class A; A() }<!>
+    <!EXPOSED_FUNCTION_RETURN_TYPE!>internal fun internalFun2() = run { class A; A() }<!>
    private fun privateFun2() = run { class A; A() }
 }
@@ -2,27 +2,27 @@ class My<T>(val value: T)

 open class Base

-val invalid1 = run {
+<!EXPOSED_PROPERTY_TYPE!>val invalid1 = run {
    class Local
    My(Local())
-}
+}<!>

 val invalid2 = My(object {})

 val invalid3 = My(object : Base() {})

-val invalid4 = run {
+<!EXPOSED_PROPERTY_TYPE!>val invalid4 = run {
    class Local
    My(My(Local()))
-}
+}<!>

-val invalid5 = run {
+<!EXPOSED_PROPERTY_TYPE!>val invalid5 = run {
    fun invalid5a() = run {
        class Local
        Local()
    }
    My(invalid5a())
-}
+}<!>

 // Valid: effectively Any
 val valid1 = object {}
@@ -1,7 +1,7 @@
 // From KT-10753
 object My : Inter() {
-    fun foo(arg: Inter): Inter = arg
-    val x: Inter? = null
+    <!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo(<!EXPOSED_PARAMETER_TYPE!>arg: Inter<!>): Inter = arg<!>
+    <!EXPOSED_PROPERTY_TYPE!>val x: Inter? = null<!>
 }

 internal open class Inter
@@ -10,21 +10,21 @@ internal open class Inter
 open class Test {
    protected class Protected

-    fun foo(x: Protected) = x
+    <!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>) = x<!>

    interface NestedInterface {
-        fun create(x: Protected)
+        fun create(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>)
    }

    class NestedClass {
-        fun create(x: Protected) = x
+        <!EXPOSED_FUNCTION_RETURN_TYPE!>fun create(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>) = x<!>
    }

    object NestedObject {
-        fun create(x: Protected) = x
+        <!EXPOSED_FUNCTION_RETURN_TYPE!>fun create(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>) = x<!>
    }

    companion object {
-        fun create(x: Protected) = x
+        <!EXPOSED_FUNCTION_RETURN_TYPE!>fun create(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>) = x<!>
    }
 }
@@ -1,3 +1,3 @@
 private enum class Foo { A, B }

-class Bar private constructor(val foo: Foo)
+class Bar private constructor(<!EXPOSED_PROPERTY_TYPE!>val foo: Foo<!>)
@@ -1,3 +1,3 @@
 private enum class Foo { A, B }

-class Bar(val foo: Foo)
+class Bar(<!EXPOSED_PARAMETER_TYPE, EXPOSED_PROPERTY_TYPE!>val foo: Foo<!>)
@@ -6,18 +6,18 @@ public interface Your: My {
    fun <T: Base> foo(): T
 }

-public class Derived<T: My>(val x: My): Base() {
+public class Derived<T: My>(<!EXPOSED_PARAMETER_TYPE, EXPOSED_PROPERTY_TYPE!>val x: My<!>): Base() {

-    constructor(xx: My?, x: My): this(xx ?: x)
+    constructor(<!EXPOSED_PARAMETER_TYPE!>xx: My?<!>, <!EXPOSED_PARAMETER_TYPE!>x: My<!>): this(xx ?: x)

-    val y: Base? = null
+    <!EXPOSED_PROPERTY_TYPE!>val y: Base? = null<!>

-    val My.z: Int
+    val <!EXPOSED_RECEIVER_TYPE!>My<!>.z: Int
        get() = 42

-    fun foo(m: My): My = m
+    <!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo(<!EXPOSED_PARAMETER_TYPE!>m: My<!>): My = m<!>

-    fun My.bar(): My = this
+    <!EXPOSED_FUNCTION_RETURN_TYPE!>fun <!EXPOSED_RECEIVER_TYPE!>My<!>.bar(): My = this<!>
 }


@@ -2,7 +2,7 @@ internal open class My

 abstract class Your {
    // invalid, List<My> is effectively internal
-    abstract fun give(): List<My>
+    <!EXPOSED_FUNCTION_RETURN_TYPE!>abstract fun give(): List<My><!>
 }

 // invalid, List<My> is effectively internal
@@ -16,7 +16,7 @@ private class TopLevelClass {
    }
 }

-private enum class TopLevelEnum(private val e: NestedEnum) {
+<!EXPOSED_FUNCTION_RETURN_TYPE, EXPOSED_FUNCTION_RETURN_TYPE!>private enum class TopLevelEnum(private val e: NestedEnum) {
    E1(NestedEntry);

    private enum class NestedEnum {
@@ -7,7 +7,7 @@ open class Foo {
 }

 class Bar: Foo() {
-    protected fun foo(): Nested? = null
+    <!EXPOSED_FUNCTION_RETURN_TYPE!>protected fun foo(): Nested? = null<!>
 }

 private fun foo(): Nested? = null
@@ -14,5 +14,5 @@ package p1

 import p2.*

-val x: X = X()
-val y: Y = <!INAPPLICABLE_CANDIDATE!>Y<!>()
+<!EXPOSED_PROPERTY_TYPE!>val x: X = X()<!>
+<!EXPOSED_PROPERTY_TYPE!>val y: Y = <!INAPPLICABLE_CANDIDATE!>Y<!>()<!>
@@ -1,7 +1,7 @@
 // !DIAGNOSTICS: -EXPOSED_PARAMETER_TYPE -NOTHING_TO_INLINE


-inline fun call(a: A) {
+inline fun call(<!EXPOSED_PARAMETER_TYPE!>a: A<!>) {
    a.test()

    privateFun()
@@ -6,7 +6,7 @@ private class S public constructor() {
    }
 }

-internal inline fun x(s: S, z: () -> Unit) {
+internal inline fun x(<!EXPOSED_PARAMETER_TYPE!>s: S<!>, z: () -> Unit) {
    z()
    S()
    s.a()
@@ -1,5 +1,5 @@
 // !DIAGNOSTICS: -EXPOSED_PARAMETER_TYPE -NOTHING_TO_INLINE
-inline fun call(a: A) {
+inline fun call(<!EXPOSED_PARAMETER_TYPE!>a: A<!>) {
    a.test()
    publishedTopLevel()
    
@@ -16,10 +16,10 @@ class MyJavaClass {
 //FILE:a.kt
 package a

-val mc = MyJavaClass()
+<!EXPOSED_PROPERTY_TYPE!>val mc = MyJavaClass()<!>
 val x = MyJavaClass.staticMethod()
 val y = MyJavaClass.NestedClass.staticMethodOfNested()
-val z = MyJavaClass.NestedClass()
+<!EXPOSED_PROPERTY_TYPE!>val z = MyJavaClass.NestedClass()<!>

 //FILE: b.kt
 package b
@@ -20,7 +20,7 @@ private fun bar() {
    xx = 30
 }

-fun makeA() = A()
+<!EXPOSED_FUNCTION_RETURN_TYPE!>fun makeA() = A()<!>

 private object PO {}

@@ -17,7 +17,7 @@ class E private constructor() {
 }

 val a = A
-val b = B
+<!EXPOSED_PROPERTY_TYPE!>val b = B<!>
 val c = C
 val d = D
 val e = E(42)
@@ -9,7 +9,7 @@ private open class A {

 private fun foo() {}

-fun makeA() = A()
+<!EXPOSED_FUNCTION_RETURN_TYPE!>fun makeA() = A()<!>

 private object PO {}

@@ -16,7 +16,7 @@ private fun bar() {
    x = 20
 }

-fun makeA() = A()
+<!EXPOSED_FUNCTION_RETURN_TYPE!>fun makeA() = A()<!>

 private object PO {}

@@ -6,14 +6,14 @@ package p
 private fun foo(a: Int) = run {
    object {
        inner class A
-        fun foo() = A()
+        <!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo() = A()<!>
    }.foo()
 }

 private fun foo() = run {
    object {
        inner class A
-        fun foo() = A()
+        <!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo() = A()<!>
    }.foo()
 }

@@ -7,39 +7,39 @@ class Outer {
    protected class Protected
    internal class Internal

-    typealias TestPrivate1 = Private
-    protected typealias TestPrivate2 = Private
-    internal typealias TestPrivate3 = Private
+    <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestPrivate1 = Private<!>
+    <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>protected typealias TestPrivate2 = Private<!>
+    <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>internal typealias TestPrivate3 = Private<!>
    private typealias TestPrivate4 = Private
-    typealias TestPrivate5 = L<Private>
+    <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestPrivate5 = L<Private><!>
    typealias TestPrivate6 = L<TestPrivate1>

-    typealias TestProtected1 = Protected
+    <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestProtected1 = Protected<!>
    protected typealias TestProtected2 = Protected
-    internal typealias TestProtected3 = Protected
+    <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>internal typealias TestProtected3 = Protected<!>
    private typealias TestProtected4 = Protected
-    typealias TestProtected5 = L<Protected>
+    <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestProtected5 = L<Protected><!>
    typealias TestProtected6 = L<TestProtected1>

-    typealias TestInternal1 = Internal
-    protected typealias TestInternal2 = Internal
+    <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestInternal1 = Internal<!>
+    <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>protected typealias TestInternal2 = Internal<!>
    internal typealias TestInternal3 = Internal
    private typealias TestInternal4 = Internal
-    typealias TestInternal5 = L<Internal>
+    <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestInternal5 = L<Internal><!>
    typealias TestInternal6 = L<TestInternal1>
 }

 private class Private
 internal class Internal

-typealias TestPrivate1 = Private
-internal typealias TestPrivate2 = Private
+<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestPrivate1 = Private<!>
+<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>internal typealias TestPrivate2 = Private<!>
 private typealias TestPrivate3 = Private
-typealias TestPrivate4 = L<Private>
+<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestPrivate4 = L<Private><!>
 typealias TestPrivate5 = L<TestPrivate1>

-typealias TestInternal1 = Internal
+<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestInternal1 = Internal<!>
 internal typealias TestInternal2 = Internal
 private typealias TestInternal3 = Internal
-typealias TestInternal4 = L<Internal>
+<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestInternal4 = L<Internal><!>
 typealias TestInternal5 = L<TestInternal1>
@@ -4,5 +4,5 @@ class C {

 typealias CAlias = C

-val test1 = CAlias
-val test1a = C
+<!EXPOSED_PROPERTY_TYPE!>val test1 = CAlias<!>
+<!EXPOSED_PROPERTY_TYPE!>val test1a = C<!>
@@ -10,6 +10,6 @@ package kotlin.sequences
 import p.*

 interface I {
-    val v1: FilteringSequence
-    val v2: IndexingSequence<String>
+    <!EXPOSED_PROPERTY_TYPE!>val v1: FilteringSequence<!>
+    <!EXPOSED_PROPERTY_TYPE!>val v2: IndexingSequence<String><!>
 }