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

[FIR] Cast error on the element name instead of the whole body

Browse Source
This commit is contained in:
rapturemain
2020-04-18 00:10:59 +03:00
committed by Mikhail Glukhikh
parent 4c639a840d
commit 8960829c01
35 changed files with 87 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/diagnostics/tests/enum/classObjectInEnumPrivate.fir.kt
Vendored
+1 -1
View File
@@ -7,4 +7,4 @@ enum class E {
fun foo() = E.values()
fun bar() = E.valueOf("ENTRY")
fun baz() = E.ENTRY
<!EXPOSED_FUNCTION_RETURN_TYPE!>fun quux() = E<!>
fun <!EXPOSED_FUNCTION_RETURN_TYPE!>quux<!>() = E
compiler/testData/diagnostics/tests/exposed/functional.fir.kt
Vendored
-12
View File
@@ -1,12 +0,0 @@
internal class My
class Your
// Both arguments should be exposed
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
<!EXPOSED_FUNCTION_RETURN_TYPE!>fun gav(<!EXPOSED_PARAMETER_TYPE!>f: () -> My<!>) = f()<!>
compiler/testData/diagnostics/tests/exposed/functional.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
internal class My
class Your
compiler/testData/diagnostics/tests/exposed/internal.fir.kt
Vendored
+2 -2
View File
@@ -10,13 +10,13 @@ internal open class Your: My() {
open class His: Your() {
protected open class Nested
// error, public from internal
<!EXPOSED_PROPERTY_TYPE!>val x = My()<!>
val <!EXPOSED_PROPERTY_TYPE!>x<!> = My()
// valid, private from internal
private fun bar() = My()
// valid, internal from internal
internal var y: My? = null
// error, protected from internal
<!EXPOSED_FUNCTION_RETURN_TYPE!>protected fun baz() = Your()<!>
protected fun <!EXPOSED_FUNCTION_RETURN_TYPE!>baz<!>() = Your()
}
internal class Their: His() {
compiler/testData/diagnostics/tests/exposed/internalFromLocal.fir.kt
Vendored
-10
View File
@@ -1,10 +0,0 @@
interface Your
class My {
internal val x = object : Your {}
<!EXPOSED_FUNCTION_RETURN_TYPE!>internal fun foo() = {
class Local
Local()
}()<!>
}
compiler/testData/diagnostics/tests/exposed/internalFromLocal.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
interface Your
class My {
compiler/testData/diagnostics/tests/exposed/local.fir.kt
Vendored
-18
View File
@@ -1,18 +0,0 @@
// invalid, depends on local class
<!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo() = run {
class A
A()
}<!>
// invalid, depends on local class
<!EXPOSED_FUNCTION_RETURN_TYPE!>fun gav() = {
class B
B()
}<!>
abstract class My
// valid, object literal here is effectively My
fun bar() = run {
object: My() {}
}
compiler/testData/diagnostics/tests/exposed/local.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// invalid, depends on local class
fun <!EXPOSED_FUNCTION_RETURN_TYPE!>foo<!>() = run {
class A
compiler/testData/diagnostics/tests/exposed/localInFunReturnType.fir.kt
Vendored
+6 -6
View File
@@ -2,27 +2,27 @@ class My<T>(val value: T)
open class Base
<!EXPOSED_FUNCTION_RETURN_TYPE!>fun invalid1() = run {
fun <!EXPOSED_FUNCTION_RETURN_TYPE!>invalid1<!>() = run {
class Local
My(Local())
}<!>
}
fun invalid2() = My(object {})
fun invalid3() = My(object : Base() {})
<!EXPOSED_FUNCTION_RETURN_TYPE!>fun invalid4() = run {
fun <!EXPOSED_FUNCTION_RETURN_TYPE!>invalid4<!>() = run {
class Local
My(My(Local()))
}<!>
}
<!EXPOSED_FUNCTION_RETURN_TYPE!>fun invalid5() = run {
fun <!EXPOSED_FUNCTION_RETURN_TYPE!>invalid5<!>() = run {
fun invalid5a() = run {
class Local
Local()
}
My(invalid5a())
}<!>
}
// Valid: effectively Any
fun valid1() = object {}
compiler/testData/diagnostics/tests/exposed/localInMemberType.fir.kt
Vendored
-21
View File
@@ -1,21 +0,0 @@
class Something {
public val publicVal1 = object { override fun toString() = "!" }
protected val protectedVal1 = object { override fun toString() = "!" }
internal val internalVal1 = object { override fun toString() = "!" }
private val privateVal1 = object { override fun toString() = "!" }
<!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() = "!" }
protected fun protectedFun1() = object { override fun toString() = "!" }
internal fun internalFun1() = object { override fun toString() = "!" }
private fun privateFun1() = object { override fun toString() = "!" }
<!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() }
}
compiler/testData/diagnostics/tests/exposed/localInMemberType.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
class Something {
public val publicVal1 = object { override fun toString() = "!" }
protected val protectedVal1 = object { override fun toString() = "!" }
compiler/testData/diagnostics/tests/exposed/localInPropertyType.fir.kt
Vendored
+6 -6
View File
@@ -2,27 +2,27 @@ class My<T>(val value: T)
open class Base
<!EXPOSED_PROPERTY_TYPE!>val invalid1 = run {
val <!EXPOSED_PROPERTY_TYPE!>invalid1<!> = run {
class Local
My(Local())
}<!>
}
val invalid2 = My(object {})
val invalid3 = My(object : Base() {})
<!EXPOSED_PROPERTY_TYPE!>val invalid4 = run {
val <!EXPOSED_PROPERTY_TYPE!>invalid4<!> = run {
class Local
My(My(Local()))
}<!>
}
<!EXPOSED_PROPERTY_TYPE!>val invalid5 = run {
val <!EXPOSED_PROPERTY_TYPE!>invalid5<!> = run {
fun invalid5a() = run {
class Local
Local()
}
My(invalid5a())
}<!>
}
// Valid: effectively Any
val valid1 = object {}
compiler/testData/diagnostics/tests/exposed/object.fir.kt
Vendored
+6 -6
View File
@@ -1,7 +1,7 @@
// From KT-10753
object My : Inter() {
<!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo(<!EXPOSED_PARAMETER_TYPE!>arg: Inter<!>): Inter = arg<!>
<!EXPOSED_PROPERTY_TYPE!>val x: Inter? = null<!>
fun <!EXPOSED_FUNCTION_RETURN_TYPE!>foo<!>(<!EXPOSED_PARAMETER_TYPE!>arg: Inter<!>): Inter = arg
val <!EXPOSED_PROPERTY_TYPE!>x<!>: Inter? = null
}
internal open class Inter
@@ -10,21 +10,21 @@ internal open class Inter
open class Test {
protected class Protected
<!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>) = x<!>
fun <!EXPOSED_FUNCTION_RETURN_TYPE!>foo<!>(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>) = x
interface NestedInterface {
fun create(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>)
}
class NestedClass {
<!EXPOSED_FUNCTION_RETURN_TYPE!>fun create(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>) = x<!>
fun <!EXPOSED_FUNCTION_RETURN_TYPE!>create<!>(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>) = x
}
object NestedObject {
<!EXPOSED_FUNCTION_RETURN_TYPE!>fun create(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>) = x<!>
fun <!EXPOSED_FUNCTION_RETURN_TYPE!>create<!>(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>) = x
}
companion object {
<!EXPOSED_FUNCTION_RETURN_TYPE!>fun create(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>) = x<!>
fun <!EXPOSED_FUNCTION_RETURN_TYPE!>create<!>(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>) = x
}
}
compiler/testData/diagnostics/tests/exposed/propertyInPrivateConstructor.fir.kt
Vendored
+1 -1
View File
@@ -1,3 +1,3 @@
private enum class Foo { A, B }
class Bar private constructor(<!EXPOSED_PROPERTY_TYPE!>val foo: Foo<!>)
class Bar private constructor(val <!EXPOSED_PROPERTY_TYPE!>foo<!>: Foo)
compiler/testData/diagnostics/tests/exposed/propertyInSimpleConstructor.fir.kt
Vendored
+1 -1
View File
@@ -1,3 +1,3 @@
private enum class Foo { A, B }
class Bar(<!EXPOSED_PARAMETER_TYPE, EXPOSED_PROPERTY_TYPE!>val foo: Foo<!>)
class Bar(<!EXPOSED_PARAMETER_TYPE!>val <!EXPOSED_PROPERTY_TYPE!>foo<!>: Foo<!>)
compiler/testData/diagnostics/tests/exposed/protectedJava.fir.kt
Vendored
+1 -1
View File
@@ -12,5 +12,5 @@ class OuterDerived: Outer() {
// valid, My has better visibility
protected class His: Outer.My()
// valid, My and Your have better visibility
<!EXPOSED_FUNCTION_RETURN_TYPE!>override fun foo(<!EXPOSED_PARAMETER_TYPE!>my: Outer.My<!>) = Outer.Your()<!>
override fun <!EXPOSED_FUNCTION_RETURN_TYPE!>foo<!>(<!EXPOSED_PARAMETER_TYPE!>my: Outer.My<!>) = Outer.Your()
}
compiler/testData/diagnostics/tests/exposed/protectedSameWay.fir.kt
Vendored
+1 -1
View File
@@ -9,5 +9,5 @@ class OuterDerived: Outer() {
// valid, My has better visibility
protected class His: Outer.My()
// valid, My and Your have better visibility
<!EXPOSED_FUNCTION_RETURN_TYPE!>override fun foo(<!EXPOSED_PARAMETER_TYPE!>my: Outer.My<!>) = Outer.Your()<!>
override fun <!EXPOSED_FUNCTION_RETURN_TYPE!>foo<!>(<!EXPOSED_PARAMETER_TYPE!>my: Outer.My<!>) = Outer.Your()
}
compiler/testData/diagnostics/tests/exposed/simple.fir.kt
Vendored
+4 -4
View File
@@ -6,18 +6,18 @@ public interface Your: My {
fun <T: Base> foo(): T
}
public class Derived<T: My>(<!EXPOSED_PARAMETER_TYPE, EXPOSED_PROPERTY_TYPE!>val x: My<!>): Base() {
public class Derived<T: My>(<!EXPOSED_PARAMETER_TYPE!>val <!EXPOSED_PROPERTY_TYPE!>x<!>: My<!>): Base() {
constructor(<!EXPOSED_PARAMETER_TYPE!>xx: My?<!>, <!EXPOSED_PARAMETER_TYPE!>x: My<!>): this(xx ?: x)
<!EXPOSED_PROPERTY_TYPE!>val y: Base? = null<!>
val <!EXPOSED_PROPERTY_TYPE!>y<!>: Base? = null
val <!EXPOSED_RECEIVER_TYPE!>My<!>.z: Int
get() = 42
<!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo(<!EXPOSED_PARAMETER_TYPE!>m: My<!>): My = m<!>
fun <!EXPOSED_FUNCTION_RETURN_TYPE!>foo<!>(<!EXPOSED_PARAMETER_TYPE!>m: My<!>): My = m
<!EXPOSED_FUNCTION_RETURN_TYPE!>fun <!EXPOSED_RECEIVER_TYPE!>My<!>.bar(): My = this<!>
fun <!EXPOSED_RECEIVER_TYPE!>My<!>.<!EXPOSED_FUNCTION_RETURN_TYPE!>bar<!>(): My = this
}
compiler/testData/diagnostics/tests/exposed/typeArgs.fir.kt
Vendored
+1 -1
View File
@@ -2,7 +2,7 @@ internal open class My
abstract class Your {
// invalid, List<My> is effectively internal
<!EXPOSED_FUNCTION_RETURN_TYPE!>abstract fun give(): List<My><!>
abstract fun <!EXPOSED_FUNCTION_RETURN_TYPE!>give<!>(): List<My>
}
// invalid, List<My> is effectively internal
compiler/testData/diagnostics/tests/imports/ImportPrivateMembersWithStar.fir.kt
Vendored
+1 -1
View File
@@ -16,7 +16,7 @@ private class TopLevelClass {
}
}
<!EXPOSED_FUNCTION_RETURN_TYPE, EXPOSED_FUNCTION_RETURN_TYPE!>private enum class TopLevelEnum(private val e: NestedEnum) {
private enum class TopLevelEnum(private val e: NestedEnum) {
E1(NestedEntry);
private enum class NestedEnum {
compiler/testData/diagnostics/tests/imports/ImportProtectedClass.fir.kt
Vendored
+1 -1
View File
@@ -7,7 +7,7 @@ open class Foo {
}
class Bar: Foo() {
<!EXPOSED_FUNCTION_RETURN_TYPE!>protected fun foo(): Nested? = null<!>
protected fun <!EXPOSED_FUNCTION_RETURN_TYPE!>foo<!>(): Nested? = null
}
private fun foo(): Nested? = null
compiler/testData/diagnostics/tests/imports/InaccessiblePrivateClass.fir.kt
Vendored
+2 -2
View File
@@ -14,5 +14,5 @@ package p1
import p2.*
<!EXPOSED_PROPERTY_TYPE!>val x: X = X()<!>
<!EXPOSED_PROPERTY_TYPE!>val y: Y = <!INAPPLICABLE_CANDIDATE!>Y<!>()<!>
val <!EXPOSED_PROPERTY_TYPE!>x<!>: X = X()
val <!EXPOSED_PROPERTY_TYPE!>y<!>: Y = <!INAPPLICABLE_CANDIDATE!>Y<!>()
compiler/testData/diagnostics/tests/j+k/packageVisibility.fir.kt
Vendored
+2 -2
View File
@@ -16,10 +16,10 @@ class MyJavaClass {
//FILE:a.kt
package a
<!EXPOSED_PROPERTY_TYPE!>val mc = MyJavaClass()<!>
val <!EXPOSED_PROPERTY_TYPE!>mc<!> = MyJavaClass()
val x = MyJavaClass.staticMethod()
val y = MyJavaClass.NestedClass.staticMethodOfNested()
<!EXPOSED_PROPERTY_TYPE!>val z = MyJavaClass.NestedClass()<!>
val <!EXPOSED_PROPERTY_TYPE!>z<!> = MyJavaClass.NestedClass()
//FILE: b.kt
package b
compiler/testData/diagnostics/tests/privateInFile/visibility.fir.kt
Vendored
+1 -1
View File
@@ -20,7 +20,7 @@ private fun bar() {
xx = 30
}
<!EXPOSED_FUNCTION_RETURN_TYPE!>fun makeA() = A()<!>
fun <!EXPOSED_FUNCTION_RETURN_TYPE!>makeA<!>() = A()
private object PO {}
compiler/testData/diagnostics/tests/resolve/constructorVsCompanion.fir.kt
Vendored
+1 -1
View File
@@ -17,7 +17,7 @@ class E private constructor() {
}
val a = A
<!EXPOSED_PROPERTY_TYPE!>val b = B<!>
val <!EXPOSED_PROPERTY_TYPE!>b<!> = B
val c = C
val d = D
val e = E(42)
compiler/testData/diagnostics/tests/scopes/visibility2.fir.kt
Vendored
+1 -1
View File
@@ -9,7 +9,7 @@ private open class A {
private fun foo() {}
<!EXPOSED_FUNCTION_RETURN_TYPE!>fun makeA() = A()<!>
fun <!EXPOSED_FUNCTION_RETURN_TYPE!>makeA<!>() = A()
private object PO {}
compiler/testData/diagnostics/tests/scopes/visibility3.fir.kt
Vendored
+1 -1
View File
@@ -16,7 +16,7 @@ private fun bar() {
x = 20
}
<!EXPOSED_FUNCTION_RETURN_TYPE!>fun makeA() = A()<!>
fun <!EXPOSED_FUNCTION_RETURN_TYPE!>makeA<!>() = A()
private object PO {}
compiler/testData/diagnostics/tests/subtyping/nestedIntoLocalClasses.fir.kt
Vendored
+2 -2
View File
@@ -6,14 +6,14 @@ package p
private fun foo(a: Int) = run {
object {
inner class A
<!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo() = A()<!>
fun <!EXPOSED_FUNCTION_RETURN_TYPE!>foo<!>() = A()
}.foo()
}
private fun foo() = run {
object {
inner class A
<!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo() = A()<!>
fun <!EXPOSED_FUNCTION_RETURN_TYPE!>foo<!>() = A()
}.foo()
}
compiler/testData/diagnostics/tests/typealias/exposedExpandedType.fir.kt
Vendored
+15 -15
View File
@@ -7,39 +7,39 @@ class Outer {
protected class Protected
internal class Internal
<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestPrivate1 = Private<!>
<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>protected typealias TestPrivate2 = Private<!>
<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>internal typealias TestPrivate3 = Private<!>
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestPrivate1<!> = Private
protected typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestPrivate2<!> = Private
internal typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestPrivate3<!> = Private
private typealias TestPrivate4 = Private
<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestPrivate5 = L<Private><!>
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestPrivate5<!> = L<Private>
typealias TestPrivate6 = L<TestPrivate1>
<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestProtected1 = Protected<!>
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestProtected1<!> = Protected
protected typealias TestProtected2 = Protected
<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>internal typealias TestProtected3 = Protected<!>
internal typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestProtected3<!> = Protected
private typealias TestProtected4 = Protected
<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestProtected5 = L<Protected><!>
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestProtected5<!> = L<Protected>
typealias TestProtected6 = L<TestProtected1>
<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestInternal1 = Internal<!>
<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>protected typealias TestInternal2 = Internal<!>
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestInternal1<!> = Internal
protected typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestInternal2<!> = Internal
internal typealias TestInternal3 = Internal
private typealias TestInternal4 = Internal
<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestInternal5 = L<Internal><!>
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestInternal5<!> = L<Internal>
typealias TestInternal6 = L<TestInternal1>
}
private class Private
internal class Internal
<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestPrivate1 = Private<!>
<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>internal typealias TestPrivate2 = Private<!>
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestPrivate1<!> = Private
internal typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestPrivate2<!> = Private
private typealias TestPrivate3 = Private
<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestPrivate4 = L<Private><!>
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestPrivate4<!> = L<Private>
typealias TestPrivate5 = L<TestPrivate1>
<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestInternal1 = Internal<!>
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestInternal1<!> = Internal
internal typealias TestInternal2 = Internal
private typealias TestInternal3 = Internal
<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestInternal4 = L<Internal><!>
typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestInternal4<!> = L<Internal>
typealias TestInternal5 = L<TestInternal1>
compiler/testData/diagnostics/tests/typealias/typeAliasInvisibleObject.fir.kt
Vendored
+2 -2
View File
@@ -4,5 +4,5 @@ class C {
typealias CAlias = C
<!EXPOSED_PROPERTY_TYPE!>val test1 = CAlias<!>
<!EXPOSED_PROPERTY_TYPE!>val test1a = C<!>
val <!EXPOSED_PROPERTY_TYPE!>test1<!> = CAlias
val <!EXPOSED_PROPERTY_TYPE!>test1a<!> = C