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

[FIR] Ignore failing test, improve DiagnosticKind, fix UPPER_BOUND

Browse Source
This commit is contained in:
Nick
2020-07-28 15:39:30 +03:00
committed by Mikhail Glukhikh
parent 9335e09149
commit 889324e972
150 changed files with 398 additions and 613 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/diagnostics/tests/EnumEntryAsType.fir.kt
Vendored
+21 -21
View File
@@ -3,53 +3,53 @@
enum class Color {
RED {
fun <T : <!OTHER_ERROR!>RED<!>> simpleName(): <!OTHER_ERROR!>RED<!> = null!!
fun <T : <!UNRESOLVED_REFERENCE!>RED<!>> simpleName(): <!UNRESOLVED_REFERENCE!>RED<!> = null!!
}
}
class MyColor(val x: <!OTHER_ERROR!>Color.RED<!>, y: <!OTHER_ERROR!>Color.RED<!>) : <!OTHER_ERROR!>Color.RED<!> {
class MyColor(val x: <!UNRESOLVED_REFERENCE!>Color.RED<!>, y: <!UNRESOLVED_REFERENCE!>Color.RED<!>) : <!UNRESOLVED_REFERENCE!>Color.RED<!> {
var z: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>Color.RED<!> = Color.RED
var z: <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>Color.RED<!> = Color.RED
set(arg: Color.RED) { z = arg }
fun foo(arg: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>Color.RED<!>): <!OTHER_ERROR!>Color.RED<!> = arg
fun foo(arg: <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>Color.RED<!>): <!UNRESOLVED_REFERENCE!>Color.RED<!> = arg
fun bar(): <!OTHER_ERROR!>Color.RED<!> {
class Local : <!OTHER_ERROR!>Color.RED<!>
fun local(arg: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>Color.RED<!>): <!OTHER_ERROR!>Color.RED<!> = arg
val temp: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>Color.RED<!> = Color.RED
temp as? <!OTHER_ERROR!>Color.RED<!>
if (temp is <!OTHER_ERROR!>Color.RED<!>) {
return temp as <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>Color.RED<!>
fun bar(): <!UNRESOLVED_REFERENCE!>Color.RED<!> {
class Local : <!UNRESOLVED_REFERENCE!>Color.RED<!>
fun local(arg: <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>Color.RED<!>): <!UNRESOLVED_REFERENCE!>Color.RED<!> = arg
val temp: <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>Color.RED<!> = Color.RED
temp as? <!UNRESOLVED_REFERENCE!>Color.RED<!>
if (temp is <!UNRESOLVED_REFERENCE!>Color.RED<!>) {
return temp as <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>Color.RED<!>
}
val obj = object : <!OTHER_ERROR!>Color.RED<!> {}
if (obj is <!OTHER_ERROR!>Color.RED<!>) {
val obj = object : <!UNRESOLVED_REFERENCE!>Color.RED<!> {}
if (obj is <!UNRESOLVED_REFERENCE!>Color.RED<!>) {
return obj
}
return Color.RED
}
}
fun create(): <!OTHER_ERROR!>Array<Color.RED>?<!> = null
fun create(): <!UNRESOLVED_REFERENCE!>Array<Color.RED>?<!> = null
interface Your<T : <!OTHER_ERROR!>Color.RED<!>>
interface Your<T : <!UNRESOLVED_REFERENCE!>Color.RED<!>>
class His : <!OTHER_ERROR!>Your<Color.RED><!>
class His : <!UNRESOLVED_REFERENCE!>Your<Color.RED><!>
fun <T : <!OTHER_ERROR!>Color.RED<!>> otherCreate(): Array<T>? = null
fun <T : <!UNRESOLVED_REFERENCE!>Color.RED<!>> otherCreate(): Array<T>? = null
typealias RedAlias = <!OTHER_ERROR!>Color.RED<!>
typealias RedAlias = <!UNRESOLVED_REFERENCE!>Color.RED<!>
typealias ArrayOfEnumEntry = <!OTHER_ERROR!>Array<Color.RED><!>
typealias ArrayOfEnumEntry = <!UNRESOLVED_REFERENCE!>Array<Color.RED><!>
typealias ArrayOfEnumEntryAlias = Array<RedAlias>
fun <T> bar(a: Any): T = a as T
fun <T> foo() {
foo<<!OTHER_ERROR, UPPER_BOUND_VIOLATED!>Color.RED<!>>()
foo<<!UNRESOLVED_REFERENCE!>Color.RED<!>>()
foo<RedAlias>()
<!INAPPLICABLE_CANDIDATE!>bar<!><Color.RED>(Color.RED)
}
fun <!OTHER_ERROR!>Array<Color.RED><!>.foo(entries: <!OTHER_ERROR!>Array<Color.RED><!>): <!OTHER_ERROR!>Array<Color.RED><!> = null!!
fun <!UNRESOLVED_REFERENCE!>Array<Color.RED><!>.foo(entries: <!UNRESOLVED_REFERENCE!>Array<Color.RED><!>): <!UNRESOLVED_REFERENCE!>Array<Color.RED><!> = null!!
compiler/testData/diagnostics/tests/LocalClassAndShortSubpackageNames.fir.kt
Vendored
+1 -1
View File
@@ -9,7 +9,7 @@ package foo
fun f() {
class Local1 {
fun g() : <!OTHER_ERROR!>bar.X?<!> = null
fun g() : <!UNRESOLVED_REFERENCE!>bar.X?<!> = null
}
class Local2 {
fun g() : foo.bar.X? = null
compiler/testData/diagnostics/tests/MultipleBounds.fir.kt
Vendored
+1 -1
View File
@@ -45,7 +45,7 @@ class Foo() {}
class Bar<T : Foo>
class Buzz<T> where T : Bar<Int>, T : <!OTHER_ERROR!>nioho<!>
class Buzz<T> where T : Bar<Int>, T : <!UNRESOLVED_REFERENCE!>nioho<!>
class X<T : Foo>
class Y<T> where T : Foo, T : Bar<Foo>
compiler/testData/diagnostics/tests/PackageInTypePosition.fir.kt
Vendored
-9
View File
@@ -1,9 +0,0 @@
// !DIAGNOSTICS: -UNUSED_PARAMETER
// FILE: a.kt
package foo
// FILE: b.kt
@<!OTHER_ERROR!>foo<!> fun bar(p: <!OTHER_ERROR!>foo<!>): <!OTHER_ERROR!>foo<!> = null!!
compiler/testData/diagnostics/tests/PackageInTypePosition.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !DIAGNOSTICS: -UNUSED_PARAMETER
// FILE: a.kt
compiler/testData/diagnostics/tests/PackageQualified.fir.kt
Vendored
+3 -3
View File
@@ -6,8 +6,8 @@ package foobar.a
import java.*
val a : java.util.List<Int>? = null
val a2 : <!OTHER_ERROR!>util.List<Int>?<!> = null
val a3 : <!OTHER_ERROR!>LinkedList<Int>?<!> = null
val a2 : <!UNRESOLVED_REFERENCE!>util.List<Int>?<!> = null
val a3 : <!UNRESOLVED_REFERENCE!>LinkedList<Int>?<!> = null
// FILE: b.kt
package foobar
@@ -21,7 +21,7 @@ package foobar.a
import java.util.*
val b : List<Int>? = a
val b1 : <!OTHER_ERROR!>util.List<Int>?<!> = a
val b1 : <!UNRESOLVED_REFERENCE!>util.List<Int>?<!> = a
// FILE: b.kt
package foobar
compiler/testData/diagnostics/tests/ResolveToJava.fir.kt
Vendored
+2 -2
View File
@@ -15,10 +15,10 @@ import java.lang.Comparable as Com
val l : MutableList<in Int> = ArrayList<Int>()
fun test(l : java.util.List<Int>) {
val x : <!OTHER_ERROR!>java.List<!>
val x : <!UNRESOLVED_REFERENCE!>java.List<!>
val y : java.util.List<Int>
val b : java.lang.Object
val z : <!OTHER_ERROR!>java.utils.List<Int><!>
val z : <!UNRESOLVED_REFERENCE!>java.utils.List<Int><!>
val f : java.io.File? = null
compiler/testData/diagnostics/tests/Unresolved.fir.kt
Vendored
+2 -2
View File
@@ -3,8 +3,8 @@ package unresolved
class Pair<A, B>(val a: A, val b: B)
fun testGenericArgumentsCount() {
val p1: <!OTHER_ERROR!>Pair<Int><!> = Pair(2, 2)
val p2: <!OTHER_ERROR!>Pair<!> = Pair(2, 2)
val p1: Pair<Int> = Pair(2, 2)
val p2: Pair = Pair(2, 2)
}
fun testUnresolved() {
compiler/testData/diagnostics/tests/annotations/AmbigiousAnnotationConstructor.fir.kt
Vendored
+1 -1
View File
@@ -2,5 +2,5 @@
import java.util.ArrayList
@ArrayList<Int>(1, 1) fun b() {}
@<!OTHER_ERROR!>Xoo<!>(<!UNRESOLVED_REFERENCE!>x<!>) fun c() {}
@<!UNRESOLVED_REFERENCE!>Xoo<!>(<!UNRESOLVED_REFERENCE!>x<!>) fun c() {}
@java.lang.Deprecated(<!UNRESOLVED_REFERENCE!>x<!>) fun a() {}
compiler/testData/diagnostics/tests/annotations/AnnotationForObject.fir.kt
Vendored
-3
View File
@@ -1,3 +0,0 @@
// Check that there won't be "Rewrite at slice ANNOTATION key" exception - EA-36935
@<!OTHER_ERROR!>someErrorAnnotation<!> object Test {
}
compiler/testData/diagnostics/tests/annotations/AnnotationForObject.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// Check that there won't be "Rewrite at slice ANNOTATION key" exception - EA-36935
@<!UNRESOLVED_REFERENCE!>someErrorAnnotation<!> object Test {
}
compiler/testData/diagnostics/tests/annotations/UnresolvedAnnotationOnObject.fir.kt
Vendored
-9
View File
@@ -1,9 +0,0 @@
package test
// Checks that there is no rewrite error at ANNOTATION slice because of resolving annotations for object in lazy resolve and resolving
// object as property (method tries to resolve annotations too).
@<!OTHER_ERROR!>BadAnnotation<!>
object SomeObject
val some = SomeObject
compiler/testData/diagnostics/tests/annotations/UnresolvedAnnotationOnObject.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
package test
// Checks that there is no rewrite error at ANNOTATION slice because of resolving annotations for object in lazy resolve and resolving
compiler/testData/diagnostics/tests/annotations/invalidTypesInAnnotationConstructor.fir.kt
Vendored
+1 -1
View File
@@ -34,7 +34,7 @@ annotation class Ann8(val p1: Array<String>,
val p4: Array<Ann1>)
annotation class Ann9(
val error: <!OTHER_ERROR!>Unresolved<!> = <!UNRESOLVED_REFERENCE!>Unresolved<!>.<!UNRESOLVED_REFERENCE!>VALUE<!>
val error: <!UNRESOLVED_REFERENCE!>Unresolved<!> = <!UNRESOLVED_REFERENCE!>Unresolved<!>.<!UNRESOLVED_REFERENCE!>VALUE<!>
)
compiler/testData/diagnostics/tests/annotations/kt1860-negative.fir.kt
Vendored
+4 -4
View File
@@ -1,10 +1,10 @@
// !WITH_NEW_INFERENCE
fun foo(@<!OTHER_ERROR!>varargs<!> f : Int) {}
fun foo(@<!UNRESOLVED_REFERENCE!>varargs<!> f : Int) {}
var bar : Int = 1
set(@<!OTHER_ERROR!>varargs<!> v) {}
set(@<!UNRESOLVED_REFERENCE!>varargs<!> v) {}
val x : (Int) -> Int = {@<!OTHER_ERROR!>varargs<!> x <!SYNTAX!>: Int -> x<!>}
val x : (Int) -> Int = {@<!UNRESOLVED_REFERENCE!>varargs<!> x <!SYNTAX!>: Int -> x<!>}
class Hello(@<!OTHER_ERROR!>varargs<!> args: Any) {
class Hello(@<!UNRESOLVED_REFERENCE!>varargs<!> args: Any) {
}
compiler/testData/diagnostics/tests/annotations/unresolvedReferenceRange.fir.kt
Vendored
+5 -5
View File
@@ -1,5 +1,5 @@
@<!OTHER_ERROR!>Ann<!> class A
@<!OTHER_ERROR!>Ann<!> class B
@<!OTHER_ERROR!>Ann<!>(1) class C
@<!OTHER_ERROR!>kotlin.Ann<!>(1) class D
@<!OTHER_ERROR!>kotlin.annotation.Ann<!>(1) class E
@<!UNRESOLVED_REFERENCE!>Ann<!> class A
@<!UNRESOLVED_REFERENCE!>Ann<!> class B
@<!UNRESOLVED_REFERENCE!>Ann<!>(1) class C
@<!UNRESOLVED_REFERENCE!>kotlin.Ann<!>(1) class D
@<!UNRESOLVED_REFERENCE!>kotlin.annotation.Ann<!>(1) class E
compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax.fir.kt
Vendored
+1 -1
View File
@@ -27,7 +27,7 @@ class Test {
fun <T> List<T>.testClassLiteral3() = b<T, Any>::class
fun <T> List<T>.testUnresolved1() = <!UNRESOLVED_REFERENCE!>unresolved<!><T>::foo
fun <T> List<T>.testUnresolved2() = a<<!OTHER_ERROR, UPPER_BOUND_VIOLATED!>unresolved<!>>::foo
fun <T> List<T>.testUnresolved2() = a<<!UNRESOLVED_REFERENCE!>unresolved<!>>::foo
fun <T> List<T>.testUnresolved3() = a<<!SYNTAX!><!>>::foo
fun <T> List<T>.testUnresolved4() = <!UNRESOLVED_REFERENCE!>unresolved<!>?::foo
}
compiler/testData/diagnostics/tests/callableReference/ea81649_errorPropertyLHS.fir.kt
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@
// MODULE: m1
// FILE: bar.kt
fun <T> bar(ff: <!OTHER_ERROR!>Err<!>.() -> Unit) {
fun <T> bar(ff: <!UNRESOLVED_REFERENCE!>Err<!>.() -> Unit) {
}
// MODULE: m2(m1)
compiler/testData/diagnostics/tests/callableReference/noExceptionOnRedCodeWithArrayLikeCall.fir.kt
Vendored
+2 -2
View File
@@ -2,10 +2,10 @@
class DTO {
val q: Int = 0
operator fun get(prop: <!OTHER_ERROR!>KProperty1<*, Int><!>): Int = 0
operator fun get(prop: <!UNRESOLVED_REFERENCE!>KProperty1<*, Int><!>): Int = 0
}
fun foo(intDTO: DTO?, p: <!OTHER_ERROR!>KProperty1<*, Int><!>) {
fun foo(intDTO: DTO?, p: <!UNRESOLVED_REFERENCE!>KProperty1<*, Int><!>) {
if (intDTO != null) {
intDTO[DTO::q]
intDTO.q
compiler/testData/diagnostics/tests/cast/IsErasedToErrorType.fir.kt
Vendored
+1 -1
View File
@@ -1 +1 @@
fun testing(a: Any) = a is <!OTHER_ERROR!>UnresolvedType<Int><!>
fun testing(a: Any) = a is <!UNRESOLVED_REFERENCE!>UnresolvedType<Int><!>
compiler/testData/diagnostics/tests/cast/bare/ErrorsInSubstitution.fir.kt
Vendored
+1 -1
View File
@@ -3,7 +3,7 @@
interface B<T>
interface G<T>: B<T>
fun f(p: <!OTHER_ERROR, OTHER_ERROR!>B<Foo><!>): Any {
fun f(p: <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>B<Foo><!>): Any {
val v = p as G
return checkSubtype<G<*>>(v)
}
compiler/testData/diagnostics/tests/cast/bare/FromErrorType.fir.kt
Vendored
+1 -1
View File
@@ -2,7 +2,7 @@
class G<T>
fun foo(p: <!OTHER_ERROR, OTHER_ERROR!>P<!>) {
fun foo(p: <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>P<!>) {
val v = p as G?
checkSubtype<G<*>>(v!!)
}
compiler/testData/diagnostics/tests/cast/bare/ToErrorType.fir.kt
Vendored
+1 -1
View File
@@ -1,6 +1,6 @@
class P
fun foo(p: P): Any {
val v = p as <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>G<!>
val v = p as <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>G<!>
return v
}
compiler/testData/diagnostics/tests/classLiteral/arrays.fir.kt
Vendored
+1 -1
View File
@@ -1,7 +1,7 @@
// !LANGUAGE: +BareArrayClassLiteral
val a01 = Array::class
val a02 = Array<<!OTHER_ERROR!>Array<!>>::class
val a02 = Array<Array>::class
val a03 = Array<Any?>::class
val a04 = Array<Array<Any?>?>::class
val a05 = Array<IntArray?>::class
compiler/testData/diagnostics/tests/classObjects/typeParametersInAnnonymousObject.fir.kt
Vendored
+2 -2
View File
@@ -15,12 +15,12 @@ fun case_3() {
}
val x = object<T, K: Comparable<K>> {
fun test() = 10 as <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>T<!> // OK
fun test() = 10 as <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>T<!> // OK
}
fun case_4() {
val x = object<T> {
fun test() = 10 as <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>T<!>
fun test() = 10 as <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>T<!>
}
val y = x.test() // type y is T
compiler/testData/diagnostics/tests/classObjects/typeParametersInAnnonymousObject_after.fir.kt
Vendored
+2 -2
View File
@@ -15,12 +15,12 @@ fun case_3() {
}
val x = object<T, K: Comparable<K>> {
fun test() = 10 as <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>T<!> // OK
fun test() = 10 as <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>T<!> // OK
}
fun case_4() {
val x = object<T> {
fun test() = 10 as <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>T<!>
fun test() = 10 as <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>T<!>
}
val y = x.test() // type y is T
compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldAsClassDelegate.fir.kt
Vendored
+1 -1
View File
@@ -23,7 +23,7 @@ object DefaultHttpClientWithFun : HttpClient by fClient() {
private fun fClient() = HttpClientImpl()
private fun <T> lazy(init: () -> T): <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>kotlin.Lazy<T><!> {
private fun <T> lazy(init: () -> T): <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>kotlin.Lazy<T><!> {
init()
null!!
}
compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/noMembers_after.fir.kt
Vendored
+1 -1
View File
@@ -9,7 +9,7 @@ public class C {
open class Base ()
class Foo : <!OTHER_ERROR!>Data<!>()
class Foo : <!UNRESOLVED_REFERENCE!>Data<!>()
companion object : DerivedAbstract()
}
compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/noMembers_before.fir.kt
Vendored
+1 -1
View File
@@ -9,7 +9,7 @@ public class C {
open class Base ()
class Foo : <!OTHER_ERROR!>Data<!>()
class Foo : <!UNRESOLVED_REFERENCE!>Data<!>()
companion object : DerivedAbstract()
}
compiler/testData/diagnostics/tests/dataClasses/errorTypesInDataClasses.fir.kt
Vendored
+2 -2
View File
@@ -1,6 +1,6 @@
// !DIAGNOSTICS: -UNUSED_VARIABLE
data class A(val i: Int, val j: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>G<!>)
data class B(val i: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>G<!>, val j: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>G<!>)
data class A(val i: Int, val j: <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>G<!>)
data class B(val i: <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>G<!>, val j: <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>G<!>)
fun fa(a: A) {
compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_3.fir.kt
Vendored
+1 -1
View File
@@ -11,7 +11,7 @@ fun test() {
const val <T> a3 = 0
lateinit val <T> a4 = 0
val <T> a5 by Delegate<Int>()
val <T> a6 by <!INAPPLICABLE_CANDIDATE!>Delegate<<!OTHER_ERROR, UPPER_BOUND_VIOLATED!>T<!>>()<!>
val <T> a6 by <!INAPPLICABLE_CANDIDATE!>Delegate<<!UNRESOLVED_REFERENCE!>T<!>>()<!>
}
class Delegate<F> {
compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_4.fir.kt
Vendored
+1 -1
View File
@@ -11,7 +11,7 @@ fun test() {
const val <T> a3 = 0
lateinit val <T> a4 = 0
val <T> a5 by Delegate<Int>()
val <T> a6 by <!INAPPLICABLE_CANDIDATE!>Delegate<<!OTHER_ERROR, UPPER_BOUND_VIOLATED!>T<!>>()<!>
val <T> a6 by <!INAPPLICABLE_CANDIDATE!>Delegate<<!UNRESOLVED_REFERENCE!>T<!>>()<!>
}
class Delegate<F> {
compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/withErrorTypes.fir.kt
Vendored
+2 -2
View File
@@ -1,4 +1,4 @@
interface T {
val x: <!OTHER_ERROR!>ErrorType<!>
fun getX(): <!OTHER_ERROR!>ErrorType1<!>
val x: <!UNRESOLVED_REFERENCE!>ErrorType<!>
fun getX(): <!UNRESOLVED_REFERENCE!>ErrorType1<!>
}
compiler/testData/diagnostics/tests/enum/ifEnumEntry.fir.kt
Vendored
+1 -1
View File
@@ -3,4 +3,4 @@ enum class MyEnum {
SECOND
}
fun foo(me: MyEnum): Boolean = if (me is <!OTHER_ERROR!>MyEnum.FIRST<!>) true else false
fun foo(me: MyEnum): Boolean = if (me is <!UNRESOLVED_REFERENCE!>MyEnum.FIRST<!>) true else false
compiler/testData/diagnostics/tests/enum/inheritFromEnumEntry.fir.kt
Vendored
+1 -1
View File
@@ -2,4 +2,4 @@ enum class E {
ENTRY
}
class A : <!OTHER_ERROR!>E.ENTRY<!>
class A : <!UNRESOLVED_REFERENCE!>E.ENTRY<!>
compiler/testData/diagnostics/tests/enum/isEnumEntry.fir.kt
Vendored
+1 -1
View File
@@ -3,4 +3,4 @@ enum class MyEnum {
SECOND
}
fun foo(me: MyEnum): Boolean = me is <!OTHER_ERROR!>MyEnum.FIRST<!>
fun foo(me: MyEnum): Boolean = me is <!UNRESOLVED_REFERENCE!>MyEnum.FIRST<!>
compiler/testData/diagnostics/tests/evaluate/inlineClasses/constructorOfUnsignedType.fir.kt
Vendored
+7 -7
View File
@@ -12,10 +12,10 @@ inline class ULong(private val l: Long)
// FILE: test.kt
annotation class AnnoUB(val ub0: <!OTHER_ERROR!>UByte<!>, val ub1: <!OTHER_ERROR!>UByte<!>)
annotation class AnnoUS(val us0: <!OTHER_ERROR!>UShort<!>, val us1: <!OTHER_ERROR!>UShort<!>)
annotation class AnnoUI(val ui0: <!OTHER_ERROR!>UInt<!>, val ui1: <!OTHER_ERROR!>UInt<!>, val ui2: <!OTHER_ERROR!>UInt<!>, val ui3: <!OTHER_ERROR!>UInt<!>)
annotation class AnnoUL(val ul0: <!OTHER_ERROR!>ULong<!>, val ul1: <!OTHER_ERROR!>ULong<!>)
annotation class AnnoUB(val ub0: <!UNRESOLVED_REFERENCE!>UByte<!>, val ub1: <!UNRESOLVED_REFERENCE!>UByte<!>)
annotation class AnnoUS(val us0: <!UNRESOLVED_REFERENCE!>UShort<!>, val us1: <!UNRESOLVED_REFERENCE!>UShort<!>)
annotation class AnnoUI(val ui0: <!UNRESOLVED_REFERENCE!>UInt<!>, val ui1: <!UNRESOLVED_REFERENCE!>UInt<!>, val ui2: <!UNRESOLVED_REFERENCE!>UInt<!>, val ui3: <!UNRESOLVED_REFERENCE!>UInt<!>)
annotation class AnnoUL(val ul0: <!UNRESOLVED_REFERENCE!>ULong<!>, val ul1: <!UNRESOLVED_REFERENCE!>ULong<!>)
const val ub0 = <!UNRESOLVED_REFERENCE!>UByte<!>(1)
const val us0 = <!UNRESOLVED_REFERENCE!>UShort<!>(2)
@@ -37,8 +37,8 @@ fun f2() {}
@AnnoUL(ul0, <!UNRESOLVED_REFERENCE!>ULong<!>(5))
fun f3() {}
const val explicit: <!OTHER_ERROR!>UInt<!> = <!UNRESOLVED_REFERENCE!>UInt<!>(2)
const val explicit: <!UNRESOLVED_REFERENCE!>UInt<!> = <!UNRESOLVED_REFERENCE!>UInt<!>(2)
const val nullable: <!OTHER_ERROR!>UInt?<!> = <!UNRESOLVED_REFERENCE!>UInt<!>(3)
const val nullable: <!UNRESOLVED_REFERENCE!>UInt?<!> = <!UNRESOLVED_REFERENCE!>UInt<!>(3)
annotation class NullableAnno(val u: <!OTHER_ERROR!>UInt?<!>)
annotation class NullableAnno(val u: <!UNRESOLVED_REFERENCE!>UInt?<!>)
compiler/testData/diagnostics/tests/functionAsExpression/WithGenericParameters.fir.kt
Vendored
+3 -3
View File
@@ -4,10 +4,10 @@
interface A
fun devNull(a: Any?){}
val generic_fun = fun<T>(t: <!OTHER_ERROR!>T<!>): T = null!!
val extension_generic_fun = fun<T><!OTHER_ERROR!>T<!>.(t: <!OTHER_ERROR!>T<!>): T = null!!
val generic_fun = fun<T>(t: <!UNRESOLVED_REFERENCE!>T<!>): T = null!!
val extension_generic_fun = fun<T><!UNRESOLVED_REFERENCE!>T<!>.(t: <!UNRESOLVED_REFERENCE!>T<!>): T = null!!
fun fun_with_where() = fun <T> <!OTHER_ERROR!>T<!>.(t: <!OTHER_ERROR!>T<!>): T where T: A = null!!
fun fun_with_where() = fun <T> <!UNRESOLVED_REFERENCE!>T<!>.(t: <!UNRESOLVED_REFERENCE!>T<!>): T where T: A = null!!
fun outer() {
compiler/testData/diagnostics/tests/functionLiterals/assignmentOperationInLambdaWithExpectedType.fir.kt
Vendored
+1 -1
View File
@@ -6,7 +6,7 @@ fun test(bal: Array<Int>) {
val b: () -> Int = { bar = 4 }
val c: () -> <!OTHER_ERROR!>UNRESOLVED<!> = { bal[2] = 3 }
val c: () -> <!UNRESOLVED_REFERENCE!>UNRESOLVED<!> = { bal[2] = 3 }
val d: () -> Int = { bar += 4 }
compiler/testData/diagnostics/tests/generics/RawTypeInIsExpression.fir.kt
Vendored
+1 -1
View File
@@ -1,7 +1,7 @@
package p
public fun foo(a: Any) {
a is <!OTHER_ERROR!>Map<Int><!>
a is Map<Int>
a is Map
a is Map<out Any?, Any?>
a is Map<*, *>
compiler/testData/diagnostics/tests/generics/RawTypeInIsPattern.fir.kt
Vendored
+2 -2
View File
@@ -1,6 +1,6 @@
public fun foo(a: Any, b: <!OTHER_ERROR!>Map<!>) {
public fun foo(a: Any, b: Map) {
when (a) {
is <!OTHER_ERROR!>Map<Int><!> -> {}
is Map<Int> -> {}
is Map -> {}
is Map<out Any?, Any?> -> {}
is Map<*, *> -> {}
compiler/testData/diagnostics/tests/generics/capturedParameters/uncheckedCast.fir.kt
Vendored
+2 -2
View File
@@ -18,11 +18,11 @@ fun <E> foo(x: Any, y: Any) : Any {
}
// bare type
if (y is <!OTHER_ERROR!>Outer.Inner<!>) {
if (y is <!UNRESOLVED_REFERENCE!>Outer.Inner<!>) {
return y
}
y as <!OTHER_ERROR, OTHER_ERROR!>Outer<*>.Inner<!>
y as <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>Outer<*>.Inner<!>
return C()
}
compiler/testData/diagnostics/tests/generics/finalUpperBoundWithoutOverride.fir.kt
Vendored
+5 -5
View File
@@ -51,19 +51,19 @@ interface MessageManager9 : Manager<Message3> {
fun <T : Message3> execute4() {}
}
object MessageManager10 : <!OTHER_ERROR!>Message5<Int><!>() {
object MessageManager10 : <!UNRESOLVED_REFERENCE!>Message5<Int><!>() {
fun <T : Int> execute() {}
}
class MessageManager11<A> : <!OTHER_ERROR!>Message5<Message5<A>><!>() {
fun <T : <!OTHER_ERROR!>Message5<A><!>> execute() {}
class MessageManager11<A> : <!UNRESOLVED_REFERENCE!>Message5<Message5<A>><!>() {
fun <T : <!UNRESOLVED_REFERENCE!>Message5<A><!>> execute() {}
}
data class MessageManager12(val x: Int) : <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>Message5<Message2><!>() {
data class MessageManager12(val x: Int) : <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>Message5<Message2><!>() {
fun <T : Message2> execute() {}
}
sealed class MessageManager13<A> : <!OTHER_ERROR!>Message5<A><!>() {
sealed class MessageManager13<A> : <!UNRESOLVED_REFERENCE!>Message5<A><!>() {
fun <T : A> execute() {}
}
compiler/testData/diagnostics/tests/generics/genericsInType.fir.kt
Vendored
+1 -1
View File
@@ -29,7 +29,7 @@ fun test() {
a<Foo.Bar<Int>.Baz>()
}
fun <T: <!OTHER_ERROR!>Foo<String.Bar><!>> x() {}
fun <T: <!UNRESOLVED_REFERENCE!>Foo<String.Bar><!>> x() {}
fun Foo<String>.Bar.ext() {}
fun ex1(a: <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Foo<String>.Bar<String><!>): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Foo<String>.Bar<String><!> {
compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromCompanionObject_after.fir.kt
Vendored
+1 -1
View File
@@ -15,7 +15,7 @@ class A {
// Does not work, could be Outer<String>.Inner<Int>
// TODO: Should work?
fun foo(x: <!OTHER_ERROR!>Inner<Int><!>) {
fun foo(x: <!UNRESOLVED_REFERENCE!>Inner<Int><!>) {
// Inner<Char>() call use companion as implicit receiver
val y: Outer<String>.Inner<Char> = Inner<Char>()
}
compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromCompanionObject_before.fir.kt
Vendored
+1 -1
View File
@@ -15,7 +15,7 @@ class A {
// Does not work, could be Outer<String>.Inner<Int>
// TODO: Should work?
fun foo(x: <!OTHER_ERROR!>Inner<Int><!>) {
fun foo(x: <!UNRESOLVED_REFERENCE!>Inner<Int><!>) {
// Inner<Char>() call use companion as implicit receiver
val y: Outer<String>.Inner<Char> = Inner<Char>()
}
compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClasses.fir.kt
Vendored
+2 -2
View File
@@ -7,14 +7,14 @@ open class Outer<X, Y> {
class Derived : Outer<String, Int>() {
fun foo(): Inner<Char> = null!!
fun baz(): <!OTHER_ERROR, OTHER_ERROR!>Alias<Char><!> = null!!
fun baz(): <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>Alias<Char><!> = null!!
}
class A : Outer<Double, Short>() {
class B : Outer<Float, Long>() {
fun bar(): Inner<String> = null!!
fun x(): <!OTHER_ERROR, OTHER_ERROR!>Alias<String><!> = null!!
fun x(): <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>Alias<String><!> = null!!
}
}
compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocal.fir.kt
Vendored
+4 -4
View File
@@ -10,12 +10,12 @@ private fun <E> foobar() = {
fun a() = A<E, X, Y, Z>()
}
typealias LocalAlias<W> = <!OTHER_ERROR!>A<E, X, Y, W><!>
typealias LocalAlias<W> = <!UNRESOLVED_REFERENCE!>A<E, X, Y, W><!>
}
class Derived : LocalOuter<Double, Short>() {
fun foo(): LocalInner<Long> = null!!
fun bar(): <!OTHER_ERROR, OTHER_ERROR!>LocalAlias<Char><!> = null!!
fun bar(): <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>LocalAlias<Char><!> = null!!
}
Derived()
@@ -27,12 +27,12 @@ private fun noParameters() = {
fun a() = A<Any, X, Y, Z>()
}
typealias LocalAlias2<W> = <!OTHER_ERROR!>A<Any, X, Y, W><!>
typealias LocalAlias2<W> = <!UNRESOLVED_REFERENCE!>A<Any, X, Y, W><!>
}
class Derived2 : LocalOuter2<Double, Short>() {
fun foo(): LocalInner2<Long> = null!!
fun bar(): <!OTHER_ERROR, OTHER_ERROR!>LocalAlias2<Char><!> = null!!
fun bar(): <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>LocalAlias2<Char><!> = null!!
}
Derived2()
compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocalInsideInner.fir.kt
Vendored
+4 -4
View File
@@ -12,12 +12,12 @@ class Outer<T> {
fun a() = A<T, F, E, X, Y, Z>()
}
typealias LocalAlias<W> = <!OTHER_ERROR!>A<T, F, E, X, Y, W><!>
typealias LocalAlias<W> = <!UNRESOLVED_REFERENCE!>A<T, F, E, X, Y, W><!>
}
class Derived : LocalOuter<Double, Short>() {
fun foo(): LocalInner<Long> = null!!
fun bar(): <!OTHER_ERROR, OTHER_ERROR!>LocalAlias<Char><!> = null!!
fun bar(): <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>LocalAlias<Char><!> = null!!
}
Derived()
@@ -29,12 +29,12 @@ class Outer<T> {
fun a() = A<T, F, Any, X, Y, Z>()
}
typealias LocalAlias2<W> = <!OTHER_ERROR!>A<T, F, Any, X, Y, W><!>
typealias LocalAlias2<W> = <!UNRESOLVED_REFERENCE!>A<T, F, Any, X, Y, W><!>
}
class Derived2 : LocalOuter2<Double, Short>() {
fun foo(): LocalInner2<Long> = null!!
fun bar(): <!OTHER_ERROR, OTHER_ERROR!>LocalAlias2<Char><!> = null!!
fun bar(): <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>LocalAlias2<Char><!> = null!!
}
Derived2()
}
compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesTransitive.fir.kt
Vendored
+1 -1
View File
@@ -10,7 +10,7 @@ open class BaseDerived2<X> : BaseDerived1<String, X>()
class Derived : BaseDerived2<Int>() {
fun foo(): Inner<Char> = null!!
fun baz(): <!OTHER_ERROR, OTHER_ERROR!>Alias<Char><!> = null!!
fun baz(): <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>Alias<Char><!> = null!!
}
fun foo() {
compiler/testData/diagnostics/tests/generics/innerClasses/importedInner.fir.kt
Vendored
+1 -1
View File
@@ -17,4 +17,4 @@ class Outer<E> {
class E
fun bar(x: <!OTHER_ERROR!>Inner<!>) {}
fun bar(x: Inner) {}
compiler/testData/diagnostics/tests/generics/innerClasses/outerArgumentsRequired.fir.kt
Vendored
+3 -3
View File
@@ -15,9 +15,9 @@ class A<T> {
val y: B<String>.C<String>? = null
val z: B<String>.D? = null
val c: <!OTHER_ERROR!>C<Int>?<!> = null
val d: <!OTHER_ERROR!>D?<!> = null
val c: C<Int>? = null
val d: D? = null
val innerMost: <!OTHER_ERROR!>Innermost<String>?<!> = null
val innerMost: Innermost<String>? = null
}
}
compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedOuter.fir.kt
Vendored
+1 -1
View File
@@ -4,7 +4,7 @@
class Outer<T> {
inner class Inner
fun foo(x: Outer<String>.Inner, y: <!OTHER_ERROR!>Outer.Inner<!>, z: Inner) {
fun foo(x: Outer<String>.Inner, y: Outer.Inner, z: Inner) {
var inner = Inner()
x.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Inner>() }
x.checkType { _<Outer<String>.Inner>() }
compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedTypesResolution.fir.kt
Vendored
+2 -2
View File
@@ -38,11 +38,11 @@ fun ok4(): Outer.Obj.Nested2<A>.Inner5<B> = null!!
fun ok5(): test.Outer.Obj.Nested2<A>.Inner5<B> = null!!
// All arguments are resolved
fun errorTypeWithArguments(): <!OTHER_ERROR!>Q<A>.W<B, C, D>.R.M<!> = null!!
fun errorTypeWithArguments(): <!UNRESOLVED_REFERENCE!>Q<A>.W<B, C, D>.R.M<!> = null!!
fun error1(): Outer<A>.Inner<B>.Inner3<C, D> = null!!
fun error2(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer<A>.Inner<B, C, D>.Inner2<!> = null!!
fun error3(): <!OTHER_ERROR!>Outer.Inner<A, B>.Inner3<C><!> = null!!
fun error3(): Outer.Inner<A, B>.Inner3<C> = null!!
fun error4(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer<A>.Nested<B>.Inner4<C><!> = null!!
fun error5(): <!WRONG_NUMBER_OF_TYPE_ARGUMENTS!>Outer<A>.Obj.Nested2<B>.Inner5<C><!> = null!!
compiler/testData/diagnostics/tests/generics/unresolvedClassifierInWhere.fir.kt
Vendored
+9 -9
View File
@@ -1,14 +1,14 @@
interface I0<T : <!OTHER_ERROR!>Unresolved0<String><!>>
interface I1<T> where T : <!OTHER_ERROR!>Unresolved1<String><!>
interface I2<T : <!OTHER_ERROR!>Unresolved2<String><!>> where T : <!OTHER_ERROR!>Unresolved3<String><!>
interface I0<T : <!UNRESOLVED_REFERENCE!>Unresolved0<String><!>>
interface I1<T> where T : <!UNRESOLVED_REFERENCE!>Unresolved1<String><!>
interface I2<T : <!UNRESOLVED_REFERENCE!>Unresolved2<String><!>> where T : <!UNRESOLVED_REFERENCE!>Unresolved3<String><!>
fun <E : <!OTHER_ERROR!>Unresolved4<String><!>> foo0() {}
fun <E> foo1() where E : <!OTHER_ERROR!>Unresolved5<String><!> {}
fun <E : <!OTHER_ERROR!>Unresolved6<String><!>> foo2() where E : <!OTHER_ERROR!>Unresolved7<String><!> {}
fun <E : <!UNRESOLVED_REFERENCE!>Unresolved4<String><!>> foo0() {}
fun <E> foo1() where E : <!UNRESOLVED_REFERENCE!>Unresolved5<String><!> {}
fun <E : <!UNRESOLVED_REFERENCE!>Unresolved6<String><!>> foo2() where E : <!UNRESOLVED_REFERENCE!>Unresolved7<String><!> {}
val <E : <!OTHER_ERROR!>Unresolved7<!>> E.p1: Int
val <E : <!UNRESOLVED_REFERENCE!>Unresolved7<!>> E.p1: Int
get() = 1
val <E> E.p2: Int where E : <!OTHER_ERROR!>Unresolved8<!>
val <E> E.p2: Int where E : <!UNRESOLVED_REFERENCE!>Unresolved8<!>
get() = 1
val <E : <!OTHER_ERROR!>Unresolved9<!>> E.p3: Int where E : <!OTHER_ERROR!>Unresolved10<!>
val <E : <!UNRESOLVED_REFERENCE!>Unresolved9<!>> E.p3: Int where E : <!UNRESOLVED_REFERENCE!>Unresolved10<!>
get() = 1
compiler/testData/diagnostics/tests/imports/ExplicitPackageImportsAmbiguity.fir.kt
Vendored
+1 -1
View File
@@ -14,4 +14,4 @@ package c
import a.x
import b.x
class Y : <!OTHER_ERROR!>x.X<!>
class Y : <!UNRESOLVED_REFERENCE!>x.X<!>
compiler/testData/diagnostics/tests/imports/propertyClassFileDependencyRecursion.fir.kt
Vendored
-17
View File
@@ -1,17 +0,0 @@
// FILE: propertyClassFileDependencyRecursion.kt
package test
import other.prop
// Note: "prop" is expected to be unresolved and replaced to Any
class PropType: <!OTHER_ERROR!>prop<!>
// Note: this time "prop" should be resolved and type should be inferred for "checkTypeProp"
val checkTypeProp = prop
// FILE: propertyClassFileDependencyRecursionOther.kt
package other
import test.PropType
val prop: PropType? = null
compiler/testData/diagnostics/tests/imports/propertyClassFileDependencyRecursion.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// FILE: propertyClassFileDependencyRecursion.kt
package test
compiler/testData/diagnostics/tests/incompleteCode/SupertypeOfErrorType.fir.kt
Vendored
+1 -1
View File
@@ -15,7 +15,7 @@ fun foo() {
}
}
fun bar(i: Int, a: <!OTHER_ERROR, OTHER_ERROR, OTHER_ERROR!>U<!>) {
fun bar(i: Int, a: <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>U<!>) {
val r = if (true) i else a
val b: Any = r
}
compiler/testData/diagnostics/tests/incompleteCode/controlStructuresErrors.fir.kt
Vendored
+1 -1
View File
@@ -19,7 +19,7 @@ fun test1() {
}
}
fun test2(l: <!OTHER_ERROR, OTHER_ERROR!>List<AA><!>) {
fun test2(l: <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>List<AA><!>) {
l.<!UNRESOLVED_REFERENCE!>map<!> {
<!UNRESOLVED_REFERENCE!>it<!>!!
}
compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/typeReferenceError.fir.kt
Vendored
+1 -1
View File
@@ -1,3 +1,3 @@
package typeReferenceError
class Pair<<!SYNTAX!><!>:<!UNRESOLVED_REFERENCE!>(val c: <!SYNTAX!><!SYNTAX!><!>fun<!><!SYNTAX!><!> <!OTHER_ERROR!>main<!><!>()
class Pair<<!SYNTAX!><!>:<!UNRESOLVED_REFERENCE!>(val c: <!SYNTAX!><!SYNTAX!><!>fun<!><!SYNTAX!><!> <!UNRESOLVED_REFERENCE!>main<!><!>()
compiler/testData/diagnostics/tests/inference/commonSuperTypeOfErrorTypes.fir.kt
Vendored
+4 -4
View File
@@ -9,13 +9,13 @@ fun <T> materialize() = null as T
fun test() {
<!INAPPLICABLE_CANDIDATE!>consume<!>(
materialize<<!OTHER_ERROR, UPPER_BOUND_VIOLATED!>Foo<Bar<ErrorType>><!>>(),
materialize<<!OTHER_ERROR, UPPER_BOUND_VIOLATED!>Foo<Bar<ErrorType>><!>>()
materialize<<!UNRESOLVED_REFERENCE!>Foo<Bar<ErrorType>><!>>(),
materialize<<!UNRESOLVED_REFERENCE!>Foo<Bar<ErrorType>><!>>()
)
<!INAPPLICABLE_CANDIDATE!>consume<!>(
materialize<<!OTHER_ERROR, UPPER_BOUND_VIOLATED!>Foo<Bar<ErrorType>><!>>(),
materialize<<!OTHER_ERROR, UPPER_BOUND_VIOLATED!>Foo<ErrorType><!>>()
materialize<<!UNRESOLVED_REFERENCE!>Foo<Bar<ErrorType>><!>>(),
materialize<<!UNRESOLVED_REFERENCE!>Foo<ErrorType><!>>()
)
}
compiler/testData/diagnostics/tests/inference/constraints/errorUpperBoundConstraint.fir.kt
Vendored
+1 -1
View File
@@ -19,7 +19,7 @@ public class Foo {
// FILE: test.kt
fun test(e: <!OTHER_ERROR, OTHER_ERROR!>ErrorType<!>) {
fun test(e: <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>ErrorType<!>) {
Foo.foo {
Sam.Result.<!INAPPLICABLE_CANDIDATE!>create<!>(e)
}
compiler/testData/diagnostics/tests/inference/kt11963.fir.kt
Vendored
+1 -1
View File
@@ -1 +1 @@
val <T : <!OTHER_ERROR!>KClass<T>.something<!>> abc
val <T : <!UNRESOLVED_REFERENCE!>KClass<T>.something<!>> abc
compiler/testData/diagnostics/tests/inference/reportingImprovements/cannotInferParameterTypeWithInference.fir.kt
Vendored
+1 -1
View File
@@ -10,7 +10,7 @@ fun test1() {
}
}
fun bar(f: (<!OTHER_ERROR!>A<!>)->Unit) {}
fun bar(f: (<!UNRESOLVED_REFERENCE!>A<!>)->Unit) {}
fun test2() {
bar { a -> } // here we don't have 'cannot infer parameter type' error
compiler/testData/diagnostics/tests/inner/accessingToJavaNestedClass.fir.kt
Vendored
+11 -11
View File
@@ -47,18 +47,18 @@ fun test() {
val ic: I.NC = I.NC()
val ii: I.NI? = null
val bc: <!OTHER_ERROR!>B.NC<!> = B.<!UNRESOLVED_REFERENCE!>NC<!>()
val bic: <!OTHER_ERROR!>B.IC<!> = B().IC()
val bi: <!OTHER_ERROR!>B.NI?<!> = null
val bc: <!UNRESOLVED_REFERENCE!>B.NC<!> = B.<!UNRESOLVED_REFERENCE!>NC<!>()
val bic: <!UNRESOLVED_REFERENCE!>B.IC<!> = B().IC()
val bi: <!UNRESOLVED_REFERENCE!>B.NI?<!> = null
val cc: <!OTHER_ERROR!>C.NC<!> = C.<!UNRESOLVED_REFERENCE!>NC<!>()
val ci: <!OTHER_ERROR!>C.NI?<!> = null
val cc: <!UNRESOLVED_REFERENCE!>C.NC<!> = C.<!UNRESOLVED_REFERENCE!>NC<!>()
val ci: <!UNRESOLVED_REFERENCE!>C.NI?<!> = null
val dc: <!OTHER_ERROR!>D.NC<!> = D.<!UNRESOLVED_REFERENCE!>NC<!>()
val dic: <!OTHER_ERROR!>D.IC<!> = D().IC()
val di: <!OTHER_ERROR!>D.NI?<!> = null
val dc: <!UNRESOLVED_REFERENCE!>D.NC<!> = D.<!UNRESOLVED_REFERENCE!>NC<!>()
val dic: <!UNRESOLVED_REFERENCE!>D.IC<!> = D().IC()
val di: <!UNRESOLVED_REFERENCE!>D.NI?<!> = null
val kc: <!OTHER_ERROR!>K.NC<!> = K.<!UNRESOLVED_REFERENCE!>NC<!>()
val kic: <!OTHER_ERROR!>K.IC<!> = K().IC()
val ki: <!OTHER_ERROR!>K.NI?<!> = null
val kc: <!UNRESOLVED_REFERENCE!>K.NC<!> = K.<!UNRESOLVED_REFERENCE!>NC<!>()
val kic: <!UNRESOLVED_REFERENCE!>K.IC<!> = K().IC()
val ki: <!UNRESOLVED_REFERENCE!>K.NI?<!> = null
}
compiler/testData/diagnostics/tests/inner/accessingToKotlinNestedClass.fir.kt
Vendored
+8 -8
View File
@@ -31,14 +31,14 @@ fun test() {
val ic: I.NC = I.NC()
val ii: I.NI? = null
val bc: <!OTHER_ERROR!>B.NC<!> = B.<!UNRESOLVED_REFERENCE!>NC<!>()
val bic: <!OTHER_ERROR!>B.IC<!> = B().IC()
val bi: <!OTHER_ERROR!>B.NI?<!> = null
val bc: <!UNRESOLVED_REFERENCE!>B.NC<!> = B.<!UNRESOLVED_REFERENCE!>NC<!>()
val bic: <!UNRESOLVED_REFERENCE!>B.IC<!> = B().IC()
val bi: <!UNRESOLVED_REFERENCE!>B.NI?<!> = null
val cc: <!OTHER_ERROR!>C.NC<!> = C.<!UNRESOLVED_REFERENCE!>NC<!>()
val ci: <!OTHER_ERROR!>C.NI?<!> = null
val cc: <!UNRESOLVED_REFERENCE!>C.NC<!> = C.<!UNRESOLVED_REFERENCE!>NC<!>()
val ci: <!UNRESOLVED_REFERENCE!>C.NI?<!> = null
val dc: <!OTHER_ERROR!>D.NC<!> = D.<!UNRESOLVED_REFERENCE!>NC<!>()
val dic: <!OTHER_ERROR!>D.IC<!> = D().IC()
val di: <!OTHER_ERROR!>D.NI?<!> = null
val dc: <!UNRESOLVED_REFERENCE!>D.NC<!> = D.<!UNRESOLVED_REFERENCE!>NC<!>()
val dic: <!UNRESOLVED_REFERENCE!>D.IC<!> = D().IC()
val di: <!UNRESOLVED_REFERENCE!>D.NI?<!> = null
}
compiler/testData/diagnostics/tests/inner/deepInnerClass.fir.kt
Vendored
+3 -3
View File
@@ -3,11 +3,11 @@ interface P<U, Y>
class A<T> {
class B {
fun test() {
class C<W>() : <!OTHER_ERROR!>P<W, T><!> {
companion object : <!OTHER_ERROR!>P<W, T><!> {
class C<W>() : <!UNRESOLVED_REFERENCE!>P<W, T><!> {
companion object : <!UNRESOLVED_REFERENCE!>P<W, T><!> {
}
inner class D : <!OTHER_ERROR!>P<W, T><!>
inner class D : <!UNRESOLVED_REFERENCE!>P<W, T><!>
}
}
}
compiler/testData/diagnostics/tests/j+k/accessClassObjectFromJava.fir.kt
Vendored
+1 -1
View File
@@ -2,7 +2,7 @@ class Foo {
companion object {
val bar = 1
fun test(a: <!OTHER_ERROR!>Foo.`object`<!>) {
fun test(a: <!UNRESOLVED_REFERENCE!>Foo.`object`<!>) {
}
compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.fir.kt
Vendored
+1 -1
View File
@@ -1,4 +1,4 @@
@<!OTHER_ERROR!><!SYNTAX!><!>myAnnotation<!> public
@<!UNRESOLVED_REFERENCE!><!SYNTAX!><!>myAnnotation<!> public
package illegal_modifiers
abstract class A() {
compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericArgumentNumberMismatch.fir.kt
Vendored
+1 -1
View File
@@ -26,5 +26,5 @@ import p.*
fun test() {
foo(M1().a)
<!INAPPLICABLE_CANDIDATE!>foo<!>(1) // error type on the declaration site
foo(1) // error type on the declaration site
}
compiler/testData/diagnostics/tests/objects/kt21515/annotationConstructor.fir.kt
Vendored
+1 -1
View File
@@ -8,6 +8,6 @@ open class Base {
class Derived : Base() {
@<!OTHER_ERROR!>Foo<!>
@<!UNRESOLVED_REFERENCE!>Foo<!>
fun foo() = 42
}
compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectNew.fir.kt
Vendored
+14 -14
View File
@@ -72,28 +72,28 @@ class C : O.B() {
val n: FromCompanionC? = null
// INVISIBLE: direct superclasses themselves.
val a: <!OTHER_ERROR!>A?<!> = null
val b: <!OTHER_ERROR!>B?<!> = null
val a: <!UNRESOLVED_REFERENCE!>A?<!> = null
val b: <!UNRESOLVED_REFERENCE!>B?<!> = null
// DEPRECATED: Classifiers from companions of direct superclasses
val e: <!OTHER_ERROR!>FromCompanionA?<!> = null
val f: <!OTHER_ERROR!>FromCompanionB?<!> = null
val e: <!UNRESOLVED_REFERENCE!>FromCompanionA?<!> = null
val f: <!UNRESOLVED_REFERENCE!>FromCompanionB?<!> = null
// INVISIBLE: "cousin" supertypes themselves
val g: <!OTHER_ERROR!>Alpha?<!> = null
val h: <!OTHER_ERROR!>Beta?<!> = null
val i: <!OTHER_ERROR!>Gamma?<!> = null
val g: <!UNRESOLVED_REFERENCE!>Alpha?<!> = null
val h: <!UNRESOLVED_REFERENCE!>Beta?<!> = null
val i: <!UNRESOLVED_REFERENCE!>Gamma?<!> = null
// DEPRECATED: classifiers from "cousin" superclasses
val k: <!OTHER_ERROR!>FromAlpha?<!> = null
val l: <!OTHER_ERROR!>FromBeta?<!> = null
val m: <!OTHER_ERROR!>FromGamma?<!> = null
val k: <!UNRESOLVED_REFERENCE!>FromAlpha?<!> = null
val l: <!UNRESOLVED_REFERENCE!>FromBeta?<!> = null
val m: <!UNRESOLVED_REFERENCE!>FromGamma?<!> = null
// INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
val o: <!OTHER_ERROR!>FromCompanionAlpha?<!> = null
val p: <!OTHER_ERROR!>FromCompanionBeta?<!> = null
val q: <!OTHER_ERROR!>FromCompanionGamma?<!> = null
val o: <!UNRESOLVED_REFERENCE!>FromCompanionAlpha?<!> = null
val p: <!UNRESOLVED_REFERENCE!>FromCompanionBeta?<!> = null
val q: <!UNRESOLVED_REFERENCE!>FromCompanionGamma?<!> = null
// DEPRECATED: Classifiers from supertypes of our own companion
val r: <!OTHER_ERROR!>FromDelta?<!> = null
val r: <!UNRESOLVED_REFERENCE!>FromDelta?<!> = null
}
compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectOld.fir.kt
Vendored
+14 -14
View File
@@ -71,28 +71,28 @@ class C : O.B() {
val n: FromCompanionC? = null
// INVISIBLE: direct superclasses themselves.
val a: <!OTHER_ERROR!>A?<!> = null
val b: <!OTHER_ERROR!>B?<!> = null
val a: <!UNRESOLVED_REFERENCE!>A?<!> = null
val b: <!UNRESOLVED_REFERENCE!>B?<!> = null
// DEPRECATED: Classifiers from companions of direct superclasses
val e: <!OTHER_ERROR!>FromCompanionA?<!> = null
val f: <!OTHER_ERROR!>FromCompanionB?<!> = null
val e: <!UNRESOLVED_REFERENCE!>FromCompanionA?<!> = null
val f: <!UNRESOLVED_REFERENCE!>FromCompanionB?<!> = null
// INVISIBLE: "cousin" supertypes themselves
val g: <!OTHER_ERROR!>Alpha?<!> = null
val h: <!OTHER_ERROR!>Beta?<!> = null
val i: <!OTHER_ERROR!>Gamma?<!> = null
val g: <!UNRESOLVED_REFERENCE!>Alpha?<!> = null
val h: <!UNRESOLVED_REFERENCE!>Beta?<!> = null
val i: <!UNRESOLVED_REFERENCE!>Gamma?<!> = null
// DEPRECATED: classifiers from "cousin" superclasses
val k: <!OTHER_ERROR!>FromAlpha?<!> = null
val l: <!OTHER_ERROR!>FromBeta?<!> = null
val m: <!OTHER_ERROR!>FromGamma?<!> = null
val k: <!UNRESOLVED_REFERENCE!>FromAlpha?<!> = null
val l: <!UNRESOLVED_REFERENCE!>FromBeta?<!> = null
val m: <!UNRESOLVED_REFERENCE!>FromGamma?<!> = null
// INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
val o: <!OTHER_ERROR!>FromCompanionAlpha?<!> = null
val p: <!OTHER_ERROR!>FromCompanionBeta?<!> = null
val q: <!OTHER_ERROR!>FromCompanionGamma?<!> = null
val o: <!UNRESOLVED_REFERENCE!>FromCompanionAlpha?<!> = null
val p: <!UNRESOLVED_REFERENCE!>FromCompanionBeta?<!> = null
val q: <!UNRESOLVED_REFERENCE!>FromCompanionGamma?<!> = null
// DEPRECATED: Classifiers from supertypes of our own companion
val r: <!OTHER_ERROR!>FromDelta?<!> = null
val r: <!UNRESOLVED_REFERENCE!>FromDelta?<!> = null
}
compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedNew.fir.kt
Vendored
-100
View File
@@ -1,100 +0,0 @@
// !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 : <!OTHER_ERROR!>A<!>()
open class b : <!OTHER_ERROR!>B<!>()
// DEPRECATED: Classifiers from companions of direct superclasses
open class e : <!OTHER_ERROR!>FromCompanionA<!>()
open class f : <!OTHER_ERROR!>FromCompanionB<!>()
// INVISIBLE: "cousin" supertypes themselves
open class g : <!OTHER_ERROR!>Alpha<!>()
open class h : <!OTHER_ERROR!>Beta<!>()
open class i : <!OTHER_ERROR!>Gamma<!>()
// DEPRECATED: classifiers from "cousin" superclasses
open class k : <!OTHER_ERROR!>FromAlpha<!>()
open class l : <!OTHER_ERROR!>FromBeta<!>()
open class m : <!OTHER_ERROR!>FromGamma<!>()
// INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
open class o : <!OTHER_ERROR!>FromCompanionAlpha<!>()
open class p : <!OTHER_ERROR!>FromCompanionBeta<!>()
open class q : <!OTHER_ERROR!>FromCompanionGamma<!>()
// DEPRECATED: Classifiers from supertypes of our own companion
open class r : <!OTHER_ERROR!>FromDelta<!>()
}
compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedNew.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
// !DIAGNOSTICS: -UNUSED_VARIABLE
compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedOld.fir.kt
Vendored
+14 -14
View File
@@ -73,28 +73,28 @@ open class C : O.B() {
open class n : FromCompanionC()
// INVISIBLE: direct superclasses themselves.
open class a : <!OTHER_ERROR!>A<!>()
open class b : <!OTHER_ERROR!>B<!>()
open class a : <!UNRESOLVED_REFERENCE!>A<!>()
open class b : <!UNRESOLVED_REFERENCE!>B<!>()
// DEPRECATED: Classifiers from companions of direct superclasses
open class e : <!OTHER_ERROR!>FromCompanionA<!>()
open class f : <!OTHER_ERROR!>FromCompanionB<!>()
open class e : <!UNRESOLVED_REFERENCE!>FromCompanionA<!>()
open class f : <!UNRESOLVED_REFERENCE!>FromCompanionB<!>()
// INVISIBLE: "cousin" supertypes themselves
open class g : <!OTHER_ERROR!>Alpha<!>()
open class h : <!OTHER_ERROR!>Beta<!>()
open class i : <!OTHER_ERROR!>Gamma<!>()
open class g : <!UNRESOLVED_REFERENCE!>Alpha<!>()
open class h : <!UNRESOLVED_REFERENCE!>Beta<!>()
open class i : <!UNRESOLVED_REFERENCE!>Gamma<!>()
// DEPRECATED: classifiers from "cousin" superclasses
open class k : <!OTHER_ERROR!>FromAlpha<!>()
open class l : <!OTHER_ERROR!>FromBeta<!>()
open class m : <!OTHER_ERROR!>FromGamma<!>()
open class k : <!UNRESOLVED_REFERENCE!>FromAlpha<!>()
open class l : <!UNRESOLVED_REFERENCE!>FromBeta<!>()
open class m : <!UNRESOLVED_REFERENCE!>FromGamma<!>()
// INVISIBLE: We don't see classifiers from companions of "cousin" superclasses
open class o : <!OTHER_ERROR!>FromCompanionAlpha<!>()
open class p : <!OTHER_ERROR!>FromCompanionBeta<!>()
open class q : <!OTHER_ERROR!>FromCompanionGamma<!>()
open class o : <!UNRESOLVED_REFERENCE!>FromCompanionAlpha<!>()
open class p : <!UNRESOLVED_REFERENCE!>FromCompanionBeta<!>()
open class q : <!UNRESOLVED_REFERENCE!>FromCompanionGamma<!>()
// DEPRECATED: Classifiers from supertypes of our own companion
open class r : <!OTHER_ERROR!>FromDelta<!>()
open class r : <!UNRESOLVED_REFERENCE!>FromDelta<!>()
}
compiler/testData/diagnostics/tests/objects/kt21515/staticsFromJavaNew.fir.kt
Vendored
-48
View File
@@ -1,48 +0,0 @@
// !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: <!OTHER_ERROR!>Classifier<!>) {
<!UNRESOLVED_REFERENCE!>method<!>()
<!UNRESOLVED_REFERENCE!>property<!>
<!UNRESOLVED_REFERENCE!>Classifier<!>()
<!UNRESOLVED_REFERENCE!>syntheticSam<!> { }
// Instance members shouldn't be affected, but we check them, just in case
val y = instanceSyntheticProperty
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 : <!OTHER_ERROR!>Classifier<!>() {
}
}
compiler/testData/diagnostics/tests/objects/kt21515/staticsFromJavaNew.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !LANGUAGE: +ProhibitVisibilityOfNestedClassifiersFromSupertypesOfCompanion
// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
compiler/testData/diagnostics/tests/objects/kt21515/staticsFromJavaOld.fir.kt
Vendored
+2 -2
View File
@@ -27,7 +27,7 @@ open class Base {
}
class Derived : Base() {
fun test(javaStaticInTypePosition: <!OTHER_ERROR!>Classifier<!>) {
fun test(javaStaticInTypePosition: <!UNRESOLVED_REFERENCE!>Classifier<!>) {
<!UNRESOLVED_REFERENCE!>method<!>()
<!UNRESOLVED_REFERENCE!>property<!>
<!UNRESOLVED_REFERENCE!>Classifier<!>()
@@ -42,7 +42,7 @@ class Derived : Base() {
<!UNRESOLVED_REFERENCE!>syntheticProperty<!> = 42
}
class JavaStaticInSupertypeList : <!OTHER_ERROR!>Classifier<!>() {
class JavaStaticInSupertypeList : <!UNRESOLVED_REFERENCE!>Classifier<!>() {
}
}
compiler/testData/diagnostics/tests/override/MissingDelegate.fir.kt
Vendored
+1 -1
View File
@@ -1,3 +1,3 @@
class C : <!OTHER_ERROR, OTHER_ERROR!>Base1<!> by <!UNRESOLVED_REFERENCE!>Base2<!>(1) {
class C : <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>Base1<!> by <!UNRESOLVED_REFERENCE!>Base2<!>(1) {
fun test() { }
}
compiler/testData/diagnostics/tests/override/OverrideWithErrors.fir.kt
Vendored
-9
View File
@@ -1,9 +0,0 @@
package test
open class A {
open fun foo(a: <!OTHER_ERROR!>E<!>) {}
}
class B : A() {
override fun foo(a: <!OTHER_ERROR!>E<!>) {}
}
compiler/testData/diagnostics/tests/override/OverrideWithErrors.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
package test
open class A {
compiler/testData/diagnostics/tests/qualifiedExpression/TypeWithError.fir.kt
Vendored
+8 -8
View File
@@ -15,18 +15,18 @@ fun test1(a: A.B.<!SYNTAX!><!>): A.B.<!SYNTAX!><!> {
val aa: A.B. <!SYNTAX!>=<!><!SYNTAX!><!> null!!
}
fun test2(a: <!OTHER_ERROR!>A.e.C<!>): <!OTHER_ERROR!>A.e.C<!> {
val aa: <!OTHER_ERROR!>A.e.C<!> = null!!
fun test2(a: <!UNRESOLVED_REFERENCE!>A.e.C<!>): <!UNRESOLVED_REFERENCE!>A.e.C<!> {
val aa: <!UNRESOLVED_REFERENCE!>A.e.C<!> = null!!
}
fun test3(a: <!OTHER_ERROR!>a.A.C<!>): <!OTHER_ERROR!>a.A.C<!> {
val aa: <!OTHER_ERROR!>a.A.C<!> = null!!
fun test3(a: <!UNRESOLVED_REFERENCE!>a.A.C<!>): <!UNRESOLVED_REFERENCE!>a.A.C<!> {
val aa: <!UNRESOLVED_REFERENCE!>a.A.C<!> = null!!
}
fun test4(a: <!OTHER_ERROR!>A.B.ee<!>): <!OTHER_ERROR!>A.B.ee<!> {
val aa: <!OTHER_ERROR!>A.B.ee<!> = null!!
fun test4(a: <!UNRESOLVED_REFERENCE!>A.B.ee<!>): <!UNRESOLVED_REFERENCE!>A.B.ee<!> {
val aa: <!UNRESOLVED_REFERENCE!>A.B.ee<!> = null!!
}
fun test5(a: <!OTHER_ERROR!>A.ee<!>): <!OTHER_ERROR!>A.ee<!> {
val aa: <!OTHER_ERROR!>A.ee<!> = null!!
fun test5(a: <!UNRESOLVED_REFERENCE!>A.ee<!>): <!UNRESOLVED_REFERENCE!>A.ee<!> {
val aa: <!UNRESOLVED_REFERENCE!>A.ee<!> = null!!
}
compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionOnErrorType.fir.kt
Vendored
+2 -2
View File
@@ -3,5 +3,5 @@ interface G<T> {
val bar: Int
}
fun <!OTHER_ERROR!>G<!>.foo() {}
val <!OTHER_ERROR!>G<!>.bar: Int get() = 42
fun G.foo() {}
val G.bar: Int get() = 42
compiler/testData/diagnostics/tests/regressions/ea65509.fir.kt
Vendored
-5
View File
@@ -1,5 +0,0 @@
// !DIAGNOSTICS: -FUNCTION_DECLARATION_WITH_NO_NAME
class ClassB() {
private inner class ClassC: <!SYNTAX!>super<!><!SYNTAX!>.<!>@<!OTHER_ERROR!>ClassA<!>()<!SYNTAX!><!> {
}
}
compiler/testData/diagnostics/tests/regressions/ea65509.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !DIAGNOSTICS: -FUNCTION_DECLARATION_WITH_NO_NAME
class ClassB() {
private inner class ClassC: <!SYNTAX!>super<!><!SYNTAX!>.<!>@<!UNRESOLVED_REFERENCE!>ClassA<!>()<!SYNTAX!><!> {
compiler/testData/diagnostics/tests/regressions/itselfAsUpperBoundLocal.fir.kt
Vendored
+1 -1
View File
@@ -1,5 +1,5 @@
// !WITH_NEW_INFERENCE
fun bar() {
fun <T: <!OTHER_ERROR!>T?<!>> foo() {}
fun <T: <!UNRESOLVED_REFERENCE!>T?<!>> foo() {}
<!INAPPLICABLE_CANDIDATE!>foo<!>()
}
compiler/testData/diagnostics/tests/regressions/kt402.fir.kt
Vendored
+1 -1
View File
@@ -1,7 +1,7 @@
package kt402
fun getTypeChecker() : (Any)->Boolean {
{ a : Any -> a is <!OTHER_ERROR!>T<!> } // reports unsupported
{ a : Any -> a is <!UNRESOLVED_REFERENCE!>T<!> } // reports unsupported
}
fun f() : (Any) -> Boolean {
return { a : Any -> a is String }
compiler/testData/diagnostics/tests/regressions/kt6508.fir.kt
Vendored
-24
View File
@@ -1,24 +0,0 @@
// !DIAGNOSTICS: -UNUSED_EXPRESSION
// FILE: foo/View.java
package foo;
public class View {}
// FILE: foo/TextView.java
package foo;
public class TextView extends View {}
// FILE: k.kt
import foo.View
//import foo.TextView
fun String.gah(view:View ?) {
if (view is <!OTHER_ERROR!>TextView<!>)
view
else <!UNRESOLVED_REFERENCE!>TextView<!>() as foo.TextView
}
compiler/testData/diagnostics/tests/regressions/kt6508.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !DIAGNOSTICS: -UNUSED_EXPRESSION
// FILE: foo/View.java
compiler/testData/diagnostics/tests/resolve/CycleInTypeArgs.fir.kt
Vendored
+2 -2
View File
@@ -1,3 +1,3 @@
class Class1<T : <!OTHER_ERROR!>Class2<Class1<X>><!>>
class Class1<T : <!UNRESOLVED_REFERENCE!>Class2<Class1<X>><!>>
class Class2<T : <!OTHER_ERROR!>Class1<Class2<X>><!>>
class Class2<T : <!UNRESOLVED_REFERENCE!>Class1<Class2<X>><!>>
compiler/testData/diagnostics/tests/scopes/classHeader/classGenericParameters.fir.kt
Vendored
-20
View File
@@ -1,20 +0,0 @@
// !DIAGNOSTICS: -UNUSED_PARAMETER
class A<T : <!OTHER_ERROR!>Nested<!>, F: <!OTHER_ERROR!>Inner<!>, G: <!OTHER_ERROR!>Interface<!>> {
class Nested
inner class Inner
interface Interface
}
class B<T, F, G> where T : <!OTHER_ERROR!>Nested<!>, F: <!OTHER_ERROR!>Inner<!>, G: <!OTHER_ERROR!>Interface<!> {
class Nested
inner class Inner
interface Interface
}
compiler/testData/diagnostics/tests/scopes/classHeader/classGenericParameters.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !DIAGNOSTICS: -UNUSED_PARAMETER
class A<T : <!UNRESOLVED_REFERENCE!>Nested<!>, F: <!UNRESOLVED_REFERENCE!>Inner<!>, G: <!UNRESOLVED_REFERENCE!>Interface<!>> {
compiler/testData/diagnostics/tests/scopes/classHeader/classParents.fir.kt
Vendored
+1 -1
View File
@@ -2,7 +2,7 @@
interface I<F, G, H>
class A(impl: Interface) : <!OTHER_ERROR!>Nested<!>(), <!OTHER_ERROR!>Interface<!> by impl, <!OTHER_ERROR!>Inner<!>, <!OTHER_ERROR!>I<Nested, Interface, Inner><!> {
class A(impl: Interface) : <!UNRESOLVED_REFERENCE!>Nested<!>(), <!UNRESOLVED_REFERENCE!>Interface<!> by impl, <!UNRESOLVED_REFERENCE!>Inner<!>, <!UNRESOLVED_REFERENCE!>I<Nested, Interface, Inner><!> {
class Nested
compiler/testData/diagnostics/tests/scopes/classHeader/objectParents.fir.kt
Vendored
+1 -1
View File
@@ -3,7 +3,7 @@ interface I<F, G>
val aImpl: A.Interface
get() = null!!
object A : <!OTHER_ERROR!>Nested<!>(), <!OTHER_ERROR!>Interface<!> by aImpl, <!OTHER_ERROR!>I<Nested, Interface><!> {
object A : <!UNRESOLVED_REFERENCE!>Nested<!>(), <!UNRESOLVED_REFERENCE!>Interface<!> by aImpl, <!UNRESOLVED_REFERENCE!>I<Nested, Interface><!> {
class Nested
compiler/testData/diagnostics/tests/scopes/inheritance/nestedClassesFromInterface.fir.kt
Vendored
-27
View File
@@ -1,27 +0,0 @@
// FILE: A.java
public interface A {
public class A_ {}
}
// FILE: 1.kt
interface B {
class B_
}
class X: A {
val a: <!OTHER_ERROR!>A_<!> = <!UNRESOLVED_REFERENCE!>A_<!>()
val b: A.A_ = A.A_()
companion object {
val a: <!OTHER_ERROR!>A_<!> = <!UNRESOLVED_REFERENCE!>A_<!>()
}
}
class Y: B {
val a: <!OTHER_ERROR!>B_<!> = <!UNRESOLVED_REFERENCE!>B_<!>()
val b: B.B_ = B.B_()
companion object {
val b: <!OTHER_ERROR!>B_<!> = <!UNRESOLVED_REFERENCE!>B_<!>()
}
}
compiler/testData/diagnostics/tests/scopes/inheritance/nestedClassesFromInterface.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// FILE: A.java
public interface A {
public class A_ {}
compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClass.fir.kt
Vendored
+4 -4
View File
@@ -7,14 +7,14 @@ open class A {
}
class C: A() {
val b: <!OTHER_ERROR!>B<!> = null!!
val b: <!UNRESOLVED_REFERENCE!>B<!> = null!!
init {
<!UNRESOLVED_REFERENCE!>B<!>()
}
object O {
val b: <!OTHER_ERROR!>B<!> = null!!
val b: <!UNRESOLVED_REFERENCE!>B<!> = null!!
init {
<!UNRESOLVED_REFERENCE!>B<!>()
@@ -22,7 +22,7 @@ class C: A() {
}
class K {
val b: <!OTHER_ERROR!>B<!> = null!!
val b: <!UNRESOLVED_REFERENCE!>B<!> = null!!
init {
<!UNRESOLVED_REFERENCE!>B<!>()
@@ -30,7 +30,7 @@ class C: A() {
}
inner class I {
val b: <!OTHER_ERROR!>B<!> = null!!
val b: <!UNRESOLVED_REFERENCE!>B<!> = null!!
init {
<!UNRESOLVED_REFERENCE!>B<!>()
compiler/testData/diagnostics/tests/scopes/inheritance/nestedFromJava.fir.kt
Vendored
+4 -4
View File
@@ -23,7 +23,7 @@ public class C extends B implements A {
// FILE: 1.kt
class X: A {
val a_s: <!OTHER_ERROR!>A_S<!> = null!!
val a_s: <!UNRESOLVED_REFERENCE!>A_S<!> = null!!
init {
<!UNRESOLVED_REFERENCE!>A_S<!>()
@@ -32,7 +32,7 @@ class X: A {
}
object xD {
val a_: <!OTHER_ERROR!>A_S<!> = null!!
val a_: <!UNRESOLVED_REFERENCE!>A_S<!> = null!!
init {
<!UNRESOLVED_REFERENCE!>A_S<!>()
@@ -66,7 +66,7 @@ class Y: B() {
}
class Z: C() {
val a_s: <!OTHER_ERROR!>A_S<!> = null!!
val a_s: <!UNRESOLVED_REFERENCE!>A_S<!> = null!!
val b_: B_ = null!!
val b_s: B_S = null!!
@@ -77,7 +77,7 @@ class Z: C() {
}
object X {
val a_s: <!OTHER_ERROR!>A_S<!> = null!!
val a_s: <!UNRESOLVED_REFERENCE!>A_S<!> = null!!
val b_: B_ = null!!
val b_s: B_S = null!!

Some files were not shown because too many files have changed in this diff Show More