jlengrand/kotlin
1
0
Fork 0
mirror of https://github.com/jlengrand/kotlin.git synced 2026-04-02 08:31:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

FIR checker: differentiate UNSAFE_CALL from INAPPLICABLE_CANDIDATE

Browse Source 
To do so, inside the root cause of inapplicable candidate errors,
we will record expected/actual type of receiver, if any.
That will help identifying inapplicable calls on nullable receiver.
This commit is contained in:
Jinseong Jeon
2021-01-26 16:03:27 -08:00
committed by Mikhail Glukhikh
parent 4b823eca21
commit e72ddbcbfe
275 changed files with 1426 additions and 1388 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
compiler/fir/analysis-tests/testData/resolve/cfg/jumps.kt vendored
View File

@@ -15,7 +15,7 @@ fun test_2(x: Int?) {
} else {
x
}
y.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
y.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>inc<!>()<!>
}
fun test_3(x: Int?) {

2
compiler/fir/analysis-tests/testData/resolve/expresssions/syntheticSmartCast.kt vendored
View File

@@ -34,7 +34,7 @@ fun test3(x: AnotherClass?) {
fun test4(x: SomeClass?) {
val bar = x?.bar
if (bar != null) {
x.bar.<!INAPPLICABLE_CANDIDATE!>length<!>
x.bar.<!UNSAFE_CALL!>length<!>
}
}

6
compiler/fir/analysis-tests/testData/resolve/smartcasts/bangbang.kt vendored
View File

@@ -26,7 +26,7 @@ fun test_3(a: A?, b: Boolean) {
if (b && a!!.foo()) {
a.foo() // OK
}
a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!> // Bad
a.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>foo<!>()<!> // Bad
}
fun test_4(a: A?, b: Boolean) {
@@ -38,9 +38,9 @@ fun test_4(a: A?, b: Boolean) {
fun test_5(a: A?, b: Boolean) {
if (b || a!!.foo()) {
a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
a.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>foo<!>()<!>
}
a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
a.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>foo<!>()<!>
}
fun <X : A?> test_6(x: X) {

16
compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/equalsToBoolean.kt vendored
View File

@@ -8,13 +8,13 @@ fun test_1(b: Boolean?) {
if ((b == true) == true) {
b.not() // OK
} else {
b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>not<!>()<!> // Bad
b.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>not<!>()<!> // Bad
}
}
fun test_2(b: Boolean?) {
if ((b == true) != true) {
b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>not<!>()<!> // Bad
b.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>not<!>()<!> // Bad
} else {
b.not() // OK
}
@@ -22,7 +22,7 @@ fun test_2(b: Boolean?) {
fun test_3(b: Boolean?) {
if ((b == true) == false) {
b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>not<!>()<!> // Bad
b.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>not<!>()<!> // Bad
} else {
b.not() // OK
}
@@ -32,13 +32,13 @@ fun test_4(b: Boolean?) {
if ((b == true) != false) {
b.not() // OK
} else {
b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>not<!>()<!> // Bad
b.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>not<!>()<!> // Bad
}
}
fun test_5(b: Boolean?) {
if ((b != true) == true) {
b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>not<!>()<!> // Bad
b.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>not<!>()<!> // Bad
} else {
b.not() // OK
}
@@ -48,7 +48,7 @@ fun test_6(b: Boolean?) {
if ((b != true) != true) {
b.not() // OK
} else {
b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>not<!>()<!> // Bad
b.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>not<!>()<!> // Bad
}
}
@@ -56,13 +56,13 @@ fun test_7(b: Boolean?) {
if ((b != true) == false) {
b.not() // OK
} else {
b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>not<!>()<!> // Bad
b.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>not<!>()<!> // Bad
}
}
fun test_8(b: Boolean?) {
if ((b != true) != false) {
b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>not<!>()<!> // Bad
b.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>not<!>()<!> // Bad
} else {
b.not() // OK
}

12
compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/jumpFromRhsOfOperator.kt vendored
View File

@@ -34,24 +34,24 @@ fun test_4(a: A?) {
fun test_5(a: A?) {
a == null || throw Exception()
a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
a.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>foo<!>()<!>
}
fun teat_6(a: A?) {
a != null && throw Exception()
a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
a.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>foo<!>()<!>
}
fun test_7(a: A?) {
if (a == null || throw Exception()) {
a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
a.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>foo<!>()<!>
}
a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
a.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>foo<!>()<!>
}
fun test_8(a: A?) {
if (a != null && throw Exception()) {
a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
a.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>foo<!>()<!>
}
a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
a.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>foo<!>()<!>
}

8
compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcastsInBranches.kt vendored
View File

@@ -104,18 +104,18 @@ fun test_7() {
if (x != null) {
x.length // OK
y.<!INAPPLICABLE_CANDIDATE!>length<!> // Bad
y.<!UNSAFE_CALL!>length<!> // Bad
z.length // OK
}
if (y != null) {
x.<!INAPPLICABLE_CANDIDATE!>length<!> // Bad
x.<!UNSAFE_CALL!>length<!> // Bad
y.length // OK
z.<!INAPPLICABLE_CANDIDATE!>length<!> // Bad
z.<!UNSAFE_CALL!>length<!> // Bad
}
if (z != null) {
x.length // OK
y.<!INAPPLICABLE_CANDIDATE!>length<!> // Bad
y.<!UNSAFE_CALL!>length<!> // Bad
z.length // OK
}
}

8
compiler/fir/analysis-tests/testData/resolve/smartcasts/equalsAndIdentity.kt vendored
View File

@@ -16,12 +16,12 @@ fun test_1(x: A, y: A?) {
fun test_2(x: A?, y: A?) {
if (x == y) {
x.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
y.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
x.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>foo<!>()<!>
y.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>foo<!>()<!>
}
if (x === y) {
x.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
y.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
x.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>foo<!>()<!>
y.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>foo<!>()<!>
}
}

56
compiler/fir/analysis-tests/testData/resolve/smartcasts/nullability.kt vendored
View File

@@ -39,18 +39,18 @@ fun test_1(x: A?) {
if (x != null) {
x.foo()
} else {
x.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
x.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>foo<!>()<!>
}
x.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
x.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>foo<!>()<!>
}
fun test_2(x: A?) {
if (x == null) {
x.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
x.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>foo<!>()<!>
} else {
x.foo()
}
x.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
x.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>foo<!>()<!>
}
fun test_3(x: A?) {
@@ -67,8 +67,8 @@ fun test_5(q: Q?) {
// `q.data` is a property that has an open getter, so we can NOT smartcast it to non-nullable MyData.
if (q?.data?.s?.inc() != null) {
q.data // good
q.data.<!INAPPLICABLE_CANDIDATE!>s<!> // should be bad
q.data.<!INAPPLICABLE_CANDIDATE!>s<!>.inc() // should be bad
q.data.<!UNSAFE_CALL!>s<!> // should be bad
q.data.<!UNSAFE_CALL!>s<!>.inc() // should be bad
}
}
@@ -76,15 +76,15 @@ fun test_6(q: Q?) {
// `q.data` is a property that has an open getter, so we can NOT smartcast it to non-nullable MyData.
q?.data?.s?.inc() ?: return
q.data // good
q.data.<!INAPPLICABLE_CANDIDATE!>s<!> // should be bad
q.data.<!INAPPLICABLE_CANDIDATE!>s<!>.inc() // should be bad
q.data.<!UNSAFE_CALL!>s<!> // should be bad
q.data.<!UNSAFE_CALL!>s<!>.inc() // should be bad
}
fun test_7(q: Q?) {
if (q?.fdata()?.fs()?.inc() != null) {
q.fdata() // good
q.fdata().<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>fs<!>()<!> // bad
q.fdata().<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>fs<!>()<!>.inc() // bad
q.fdata().<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>fs<!>()<!> // bad
q.fdata().<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>fs<!>()<!>.inc() // bad
}
}
@@ -98,44 +98,44 @@ fun test_9(a: Int, b: Int?) {
if (a == b) {
b.inc()
}
b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
b.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>inc<!>()<!>
if (a === b) {
b.inc()
}
b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
b.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>inc<!>()<!>
if (b == a) {
b.inc()
}
b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
b.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>inc<!>()<!>
if (b === a) {
b.inc()
}
b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
b.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>inc<!>()<!>
}
fun test_10(a: Int?, b: Int?) {
if (a == b) {
b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
b.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>inc<!>()<!>
}
b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
b.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>inc<!>()<!>
if (a === b) {
b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
b.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>inc<!>()<!>
}
b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
b.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>inc<!>()<!>
if (b == a) {
b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
b.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>inc<!>()<!>
}
b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
b.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>inc<!>()<!>
if (b === a) {
b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
b.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>inc<!>()<!>
}
b.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>inc<!>()<!>
b.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>inc<!>()<!>
}
fun test_11(q: QImpl?, q2: QImpl) {
@@ -148,8 +148,8 @@ fun test_11(q: QImpl?, q2: QImpl) {
// Smartcasting of `q.data` should have no effect on `q2.data`.
// Issue: Smartcasting of QImpl.data affects all instances
q2.data
q2.data.<!INAPPLICABLE_CANDIDATE!>s<!> // should be bad
q2.data.<!INAPPLICABLE_CANDIDATE!>s<!>.inc() // should be bad
q2.data.<!UNSAFE_CALL!>s<!> // should be bad
q2.data.<!UNSAFE_CALL!>s<!>.inc() // should be bad
if (q2.data != null) {
q2.data.s
@@ -162,8 +162,8 @@ fun test_12(q: QImplWithCustomGetter?) {
// `q.data` is a property that has an open getter, so we can NOT smartcast it to non-nullable MyData.
if (q?.data?.s?.inc() != null) {
q.data // good
q.data.<!INAPPLICABLE_CANDIDATE!>s<!> // should be bad
q.data.<!INAPPLICABLE_CANDIDATE!>s<!>.inc() // should be bad
q.data.<!UNSAFE_CALL!>s<!> // should be bad
q.data.<!UNSAFE_CALL!>s<!>.inc() // should be bad
}
}
@@ -171,7 +171,7 @@ fun test_13(q: QImplMutable?) {
// `q.data` is a property that is mutable, so we can NOT smartcast it to non-nullable MyData.
if (q?.data?.s?.inc() != null) {
q.data // good
q.data.<!INAPPLICABLE_CANDIDATE!>s<!> // should be bad
q.data.<!INAPPLICABLE_CANDIDATE!>s<!>.inc() // should be bad
q.data.<!UNSAFE_CALL!>s<!> // should be bad
q.data.<!UNSAFE_CALL!>s<!>.inc() // should be bad
}
}

2
compiler/fir/analysis-tests/testData/resolve/smartcasts/orInWhenBranch.kt vendored
View File

@@ -22,6 +22,6 @@ fun test_3(a: Any?, b: Boolean) {
fun test_4(a: Any?, b: Boolean) {
if (a is String || b) {
a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!> // Should be Bad
a.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>foo<!>()<!> // Should be Bad
}
}

8
compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCallAndEqualityToBool.kt vendored
View File

@@ -5,7 +5,7 @@ fun test_1(s: String?) {
if (s?.check() == true) {
s.length // Should be OK
} else {
s.<!INAPPLICABLE_CANDIDATE!>length<!> // Should be bad
s.<!UNSAFE_CALL!>length<!> // Should be bad
}
}
@@ -13,13 +13,13 @@ fun test_2(s: String?) {
if (s?.check() == false) {
s.length // Should be OK
} else {
s.<!INAPPLICABLE_CANDIDATE!>length<!> // Should be bad
s.<!UNSAFE_CALL!>length<!> // Should be bad
}
}
fun test_3(s: String?) {
if (s?.check() != true) {
s.<!INAPPLICABLE_CANDIDATE!>length<!> // Should be bad
s.<!UNSAFE_CALL!>length<!> // Should be bad
} else {
s.length // Should be OK
}
@@ -27,7 +27,7 @@ fun test_3(s: String?) {
fun test_4(s: String?) {
if (s?.check() != false) {
s.<!INAPPLICABLE_CANDIDATE!>length<!> // Should be bad
s.<!UNSAFE_CALL!>length<!> // Should be bad
} else {
s.length // Should be OK
}

6
compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCalls.kt vendored
View File

@@ -5,7 +5,7 @@ fun String.let(block: () -> Unit) {}
fun test(x: String?) {
x?.foo(x.length == 1)
x.<!INAPPLICABLE_CANDIDATE!>length<!>
x.<!UNSAFE_CALL!>length<!>
}
interface A {
@@ -27,12 +27,12 @@ fun test_3(x: Any) {
fun test_4(x: A?) {
x?.id()?.bool()
x.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>id<!>()<!>
x.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>id<!>()<!>
}
fun Any?.boo(b: Boolean) {}
fun test_5(x: A?) {
x?.let { return }?.boo(x.bool())
x.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>id<!>()<!>
x.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>id<!>()<!>
}

2
compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/delayedAssignment.kt vendored
View File

@@ -11,5 +11,5 @@ fun test(b: Boolean) {
} else {
a = null
}
a.<!INAPPLICABLE_CANDIDATE{LT}!><!INAPPLICABLE_CANDIDATE{PSI}!>foo<!>()<!>
a.<!UNSAFE_CALL{LT}!><!UNSAFE_CALL{PSI}!>foo<!>()<!>
}

2
compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/smartcastAfterReassignment.kt vendored
View File

@@ -18,5 +18,5 @@ fun test_3() {
x = ""
x.length
x = null
x.<!INAPPLICABLE_CANDIDATE!>length<!>
x.<!UNSAFE_CALL!>length<!>
}

2
compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromLibrary/notIsNullOrEmpty.kt vendored
View File

@@ -7,7 +7,7 @@ fun test_1(s: String?) {
fun test_2(s: String?) {
// contracts related
if (s.isNullOrEmpty()) {
s.<!INAPPLICABLE_CANDIDATE!>length<!> // Should be bad
s.<!INAPPLICABLE_CANDIDATE{LT}, UNSAFE_CALL!>length<!> // Should be bad
} else {
s.length // Should be OK
}

2
compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/eqNotEq.kt vendored
View File

@@ -21,7 +21,7 @@ fun test_1(x: String?) {
if (checkNotNull(x)) {
x.length // OK
} else {
x.<!INAPPLICABLE_CANDIDATE!>length<!> // Error
x.<!INAPPLICABLE_CANDIDATE{LT}, UNSAFE_CALL!>length<!> // Error
}
}

2
compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies/receivers.kt vendored
View File

@@ -27,7 +27,7 @@ fun test_3(x: A?) {
with(x) {
myRequireNotNull()
}
x.<!INAPPLICABLE_CANDIDATE!>foo<!>()
x.<!INAPPLICABLE_CANDIDATE{LT}, UNSAFE_CALL!>foo<!>()
}
fun test_4(x: A?) {

20
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDestructuringDeclarationChecker.kt
View File

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.fir.analysis.checkers.extended.report
import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
import org.jetbrains.kotlin.fir.declarations.FirProperty
import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
import org.jetbrains.kotlin.fir.declarations.FirValueParameter
import org.jetbrains.kotlin.fir.declarations.FirVariable
import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
@@ -20,8 +21,12 @@ import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeAmbiguityError
import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeInapplicableCandidateError
import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedNameError
import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
import org.jetbrains.kotlin.fir.types.ConeKotlinType
import org.jetbrains.kotlin.fir.types.coneTypeSafe
import org.jetbrains.kotlin.fir.types.isNullable
object FirDestructuringDeclarationChecker : FirPropertyChecker() {
override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) {
@@ -65,8 +70,8 @@ object FirDestructuringDeclarationChecker : FirPropertyChecker() {
val originalDestructuringDeclarationOrInitializerSource = originalDestructuringDeclarationOrInitializer.source ?: return
val originalDestructuringDeclarationType =
when (originalDestructuringDeclarationOrInitializer) {
is FirVariable<*> -> originalDestructuringDeclarationOrInitializer.returnTypeRef
is FirExpression -> originalDestructuringDeclarationOrInitializer.typeRef
is FirVariable<*> -> originalDestructuringDeclarationOrInitializer.returnTypeRef.coneTypeSafe<ConeKotlinType>()
is FirExpression -> originalDestructuringDeclarationOrInitializer.typeRef.coneTypeSafe<ConeKotlinType>()
else -> null
} ?: return
@@ -89,7 +94,16 @@ object FirDestructuringDeclarationChecker : FirPropertyChecker() {
)
)
}
// TODO: COMPONENT_FUNCTION_ON_NULLABLE
is ConeInapplicableCandidateError -> {
if (originalDestructuringDeclarationType.isNullable) {
reporter.report(
FirErrors.COMPONENT_FUNCTION_ON_NULLABLE.on(
originalDestructuringDeclarationOrInitializerSource,
(diagnostic.candidateSymbol.fir as FirSimpleFunction).name
)
)
}
}
// TODO: COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH
}
}

33
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ErrorNodeDiagnosticCollectorComponent.kt
View File

@@ -10,9 +10,7 @@ import org.jetbrains.kotlin.fir.FirFakeSourceElementKind
import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.collectors.AbstractDiagnosticCollector
import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticFactory0
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
import org.jetbrains.kotlin.fir.analysis.diagnostics.*
import org.jetbrains.kotlin.fir.declarations.FirErrorFunction
import org.jetbrains.kotlin.fir.diagnostics.*
import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind.*
@@ -20,8 +18,9 @@ import org.jetbrains.kotlin.fir.expressions.FirErrorExpression
import org.jetbrains.kotlin.fir.expressions.FirErrorLoop
import org.jetbrains.kotlin.fir.expressions.FirErrorResolvedQualifier
import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
import org.jetbrains.kotlin.fir.resolve.calls.InapplicableWrongReceiver
import org.jetbrains.kotlin.fir.resolve.diagnostics.*
import org.jetbrains.kotlin.fir.types.FirErrorTypeRef
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.resolve.calls.tower.isSuccess
import org.jetbrains.kotlin.utils.addToStdlib.safeAs
@@ -62,7 +61,10 @@ class ErrorNodeDiagnosticCollectorComponent(collector: AbstractDiagnosticCollect
// Will be handled by [FirDestructuringDeclarationChecker]
if (source.elementType == KtNodeTypes.DESTRUCTURING_DECLARATION_ENTRY) {
// TODO: if all diagnostics are supported, we don't need the following check, and will bail out based on element type.
if (diagnostic is ConeUnresolvedNameError || diagnostic is ConeAmbiguityError) {
if (diagnostic is ConeUnresolvedNameError ||
diagnostic is ConeAmbiguityError ||
diagnostic is ConeInapplicableCandidateError
) {
return
}
}
@@ -72,7 +74,7 @@ class ErrorNodeDiagnosticCollectorComponent(collector: AbstractDiagnosticCollect
is ConeUnresolvedSymbolError -> FirErrors.UNRESOLVED_REFERENCE.on(source, diagnostic.classId.asString())
is ConeUnresolvedNameError -> FirErrors.UNRESOLVED_REFERENCE.on(source, diagnostic.name.asString())
is ConeHiddenCandidateError -> FirErrors.HIDDEN.on(source, diagnostic.candidateSymbol)
is ConeInapplicableCandidateError -> FirErrors.INAPPLICABLE_CANDIDATE.on(source, diagnostic.candidateSymbol)
is ConeInapplicableCandidateError -> mapInapplicableCandidateError(diagnostic, source)
is ConeAmbiguityError -> if (!diagnostic.applicability.isSuccess) {
FirErrors.NONE_APPLICABLE.on(source, diagnostic.candidates)
} else {
@@ -98,6 +100,25 @@ class ErrorNodeDiagnosticCollectorComponent(collector: AbstractDiagnosticCollect
reporter.report(coneDiagnostic)
}
private fun mapInapplicableCandidateError(
diagnostic: ConeInapplicableCandidateError,
source: FirSourceElement,
): FirDiagnostic<*> {
// TODO: Need to distinguish SMARTCAST_IMPOSSIBLE
// TODO: handle other UNSAFE_* variants: invoke, infix, operator
val rootCause = diagnostic.diagnostics.find { it.applicability == diagnostic.applicability }
return if (rootCause != null &&
rootCause is InapplicableWrongReceiver &&
rootCause.actualType?.isNullable == true &&
(rootCause.expectedType == null || !rootCause.expectedType!!.isMarkedNullable)
) {
// TODO: report on call operation node, e.g., x<!>.<!>length instead of x.<!>length<!>
FirErrors.UNSAFE_CALL.on(source, rootCause.actualType!!)
} else {
FirErrors.INAPPLICABLE_CANDIDATE.on(source, diagnostic.candidateSymbol)
}
}
private fun ConeSimpleDiagnostic.getFactory(): FirDiagnosticFactory0<FirSourceElement, *> {
@Suppress("UNCHECKED_CAST")
return when (kind) {

19
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt
View File

@@ -37,6 +37,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.CAN_BE_VAL
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.CLASS_IN_SUPERTYPE_FOR_ENUM
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.COMPONENT_FUNCTION_AMBIGUITY
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.COMPONENT_FUNCTION_MISSING
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.COMPONENT_FUNCTION_ON_NULLABLE
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.CONFLICTING_OVERLOADS
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.CONFLICTING_PROJECTION
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.CONSTRUCTOR_IN_INTERFACE
@@ -137,6 +138,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TYPE_PARAMETER_AS
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.UNINITIALIZED_VARIABLE
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.UNRESOLVED_LABEL
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.UNRESOLVED_REFERENCE
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.UNSAFE_CALL
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.UNUSED_VARIABLE
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.UPPER_BOUND_VIOLATED
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.USELESS_VARARG_ON_PARAMETER
@@ -418,6 +420,11 @@ class FirDefaultErrorMessages : DefaultErrorMessages.Extension {
TO_STRING,
AMBIGUOUS_CALLS
)
map.put(
COMPONENT_FUNCTION_ON_NULLABLE,
"Not nullable value required to call ''{0}()'' function of destructuring declaration initializer",
TO_STRING
)
// Control flow diagnostics
map.put(UNINITIALIZED_VARIABLE, "{0} must be initialized before access", PROPERTY_NAME)
@@ -431,6 +438,18 @@ class FirDefaultErrorMessages : DefaultErrorMessages.Extension {
map.put(LEAKED_IN_PLACE_LAMBDA, "Leaked in-place lambda: {2}", SYMBOL)
map.put(FirErrors.WRONG_IMPLIES_CONDITION, "Wrong implies condition")
// Nullability
map.put(
UNSAFE_CALL,
"Only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type {0}",
RENDER_TYPE
)
//map.put(
// UNSAFE_IMPLICIT_INVOKE_CALL,
// "Reference has a nullable type ''{0}'', use explicit \"?.invoke\" to make a function-like call instead.",
// RENDER_TYPE
//)
// Extended checkers group
map.put(REDUNDANT_VISIBILITY_MODIFIER, "Redundant visibility modifier")
map.put(REDUNDANT_MODALITY_MODIFIER, "Redundant modality modifier")

7
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt
View File

@@ -13,7 +13,8 @@ import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.types.ConeKotlinType
import org.jetbrains.kotlin.fir.types.render
object FirDiagnosticRenderers {
val NULLABLE_STRING = Renderer<String?> { it ?: "null" }
@@ -58,9 +59,9 @@ object FirDiagnosticRenderers {
name.asString()
}
val RENDER_TYPE = Renderer { typeRef: FirTypeRef ->
val RENDER_TYPE = Renderer { t: ConeKotlinType ->
// TODO: need a way to tune granuality, e.g., without parameter names in functional types.
typeRef.render()
t.render()
}
val AMBIGUOUS_CALLS = Renderer { candidates: Collection<AbstractFirBasedSymbol<*>> ->

13
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt
View File

@@ -197,9 +197,9 @@ object FirErrors {
// Destructuring declaration
val INITIALIZER_REQUIRED_FOR_DESTRUCTURING_DECLARATION by error0<FirSourceElement, KtDestructuringDeclaration>()
val COMPONENT_FUNCTION_MISSING by error2<FirSourceElement, PsiElement, Name, FirTypeRef>()
val COMPONENT_FUNCTION_AMBIGUITY by error2<FirSourceElement, PsiElement, Name, Collection<AbstractFirBasedSymbol<*>>>()
// TODO: val COMPONENT_FUNCTION_ON_NULLABLE by ...
val COMPONENT_FUNCTION_MISSING by error2<FirSourceElement, KtExpression, Name, ConeKotlinType>()
val COMPONENT_FUNCTION_AMBIGUITY by error2<FirSourceElement, KtExpression, Name, Collection<AbstractFirBasedSymbol<*>>>()
val COMPONENT_FUNCTION_ON_NULLABLE by error1<FirSourceElement, KtExpression, Name>()
// TODO: val COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH by ...
// Control flow diagnostics
@@ -208,6 +208,13 @@ object FirErrors {
val LEAKED_IN_PLACE_LAMBDA by error1<FirSourceElement, PsiElement, AbstractFirBasedSymbol<*>>()
val WRONG_IMPLIES_CONDITION by warning0<FirSourceElement, PsiElement>()
// Nullability
val UNSAFE_CALL by error1<FirSourceElement, PsiElement, ConeKotlinType>()
// TODO: val UNSAFE_IMPLICIT_INVOKE_CALL by error1<FirSourceElement, PsiElement, ConeKotlinType>()
// TODO: val UNSAFE_INFIX_CALL by ...
// TODO: val UNSAFE_OPERATOR_CALL by ...
// TODO: val UNEXPECTED_SAFE_CALL by ...
// Extended checkers group
val REDUNDANT_VISIBILITY_MODIFIER by warning0<FirSourceElement, KtModifierListOwner>(SourceElementPositioningStrategies.VISIBILITY_MODIFIER)
val REDUNDANT_MODALITY_MODIFIER by warning0<FirSourceElement, KtModifierListOwner>(SourceElementPositioningStrategies.MODALITY_MODIFIER)

6
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Arguments.kt
View File

@@ -310,7 +310,7 @@ private fun checkApplicabilityForArgumentType(
if (expectedType == null) return
if (isReceiver && isDispatch) {
if (!expectedType.isNullable && argumentType.isMarkedNullable) {
sink.reportDiagnostic(InapplicableWrongReceiver)
sink.reportDiagnostic(InapplicableWrongReceiver(expectedType, argumentType))
}
return
}
@@ -323,10 +323,10 @@ private fun checkApplicabilityForArgumentType(
val nullableExpectedType = expectedType.withNullability(ConeNullability.NULLABLE, context.session.typeContext)
if (csBuilder.addSubtypeConstraintIfCompatible(argumentType, nullableExpectedType, position)) {
sink.reportDiagnostic(InapplicableWrongReceiver) // TODO
sink.reportDiagnostic(InapplicableWrongReceiver(expectedType, argumentType)) // TODO
} else {
csBuilder.addSubtypeConstraint(argumentType, expectedType, position)
sink.reportDiagnostic(InapplicableWrongReceiver)
sink.reportDiagnostic(InapplicableWrongReceiver(expectedType, argumentType))
}
}
}

6
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionDiagnostic.kt
View File

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.resolve.calls
import org.jetbrains.kotlin.fir.declarations.FirFunction
import org.jetbrains.kotlin.fir.declarations.FirValueParameter
import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.types.ConeKotlinType
import org.jetbrains.kotlin.resolve.calls.tower.CandidateApplicability
abstract class ResolutionDiagnostic(val applicability: CandidateApplicability)
@@ -57,7 +58,10 @@ object HiddenCandidate : ResolutionDiagnostic(CandidateApplicability.HIDDEN)
object ResolvedWithLowPriority : ResolutionDiagnostic(CandidateApplicability.RESOLVED_LOW_PRIORITY)
object InapplicableWrongReceiver : ResolutionDiagnostic(CandidateApplicability.INAPPLICABLE_WRONG_RECEIVER)
class InapplicableWrongReceiver(
val expectedType: ConeKotlinType? = null,
val actualType: ConeKotlinType? = null,
) : ResolutionDiagnostic(CandidateApplicability.INAPPLICABLE_WRONG_RECEIVER)
object LowerPriorityToPreserveCompatibilityDiagnostic : ResolutionDiagnostic(CandidateApplicability.RESOLVED_NEED_PRESERVE_COMPATIBILITY)

8
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt
View File

@@ -39,17 +39,17 @@ internal object CheckExplicitReceiverConsistency : ResolutionStage() {
when (receiverKind) {
NO_EXPLICIT_RECEIVER -> {
if (explicitReceiver != null && explicitReceiver !is FirResolvedQualifier && !explicitReceiver.isSuperReferenceExpression()) {
return sink.yieldDiagnostic(InapplicableWrongReceiver)
return sink.yieldDiagnostic(InapplicableWrongReceiver(actualType = explicitReceiver.typeRef.coneTypeSafe()))
}
}
EXTENSION_RECEIVER, DISPATCH_RECEIVER -> {
if (explicitReceiver == null) {
return sink.yieldDiagnostic(InapplicableWrongReceiver)
return sink.yieldDiagnostic(InapplicableWrongReceiver())
}
}
BOTH_RECEIVERS -> {
if (explicitReceiver == null) {
return sink.yieldDiagnostic(InapplicableWrongReceiver)
return sink.yieldDiagnostic(InapplicableWrongReceiver())
}
// Here we should also check additional invoke receiver
}
@@ -105,7 +105,7 @@ object CheckDispatchReceiver : ResolutionStage() {
val dispatchReceiverValueType = candidate.dispatchReceiverValue?.type ?: return
if (!AbstractNullabilityChecker.isSubtypeOfAny(context.session.typeContext, dispatchReceiverValueType)) {
sink.yieldDiagnostic(InapplicableWrongReceiver)
sink.yieldDiagnostic(InapplicableWrongReceiver(actualType = dispatchReceiverValueType))
}
}
}

5
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/diagnostics/FirDiagnostics.kt
View File

@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
import org.jetbrains.kotlin.fir.render
import org.jetbrains.kotlin.fir.resolve.calls.Candidate
import org.jetbrains.kotlin.fir.resolve.calls.ResolutionDiagnostic
import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
@@ -37,14 +38,16 @@ class ConeHiddenCandidateError(
override val reason: String get() = "HIDDEN: ${describeSymbol(candidateSymbol)} is invisible"
}
class ConeInapplicableCandidateError(
class ConeInapplicableCandidateError private constructor(
val applicability: CandidateApplicability,
val candidateSymbol: AbstractFirBasedSymbol<*>,
val diagnostics: List<ResolutionDiagnostic>,
val errors: List<ConstraintSystemError>
) : ConeDiagnostic() {
constructor(applicability: CandidateApplicability, candidate: Candidate) : this(
applicability,
candidate.symbol,
candidate.diagnostics,
candidate.system.errors
)

6
compiler/testData/diagnostics/tests/BreakContinue.fir.kt vendored
View File

@@ -29,7 +29,7 @@ class C {
while (a == null) {
break;
}
a.<!INAPPLICABLE_CANDIDATE!>compareTo<!>("2")
a.<!UNSAFE_CALL!>compareTo<!>("2")
}
fun notContainsBreak(a: String?, b: String?) {
@@ -70,7 +70,7 @@ class C {
break@l
}
}
a.<!INAPPLICABLE_CANDIDATE!>compareTo<!>("2")
a.<!UNSAFE_CALL!>compareTo<!>("2")
}
fun unresolvedBreak(a: String?, array: Array<Int>) {
@@ -80,7 +80,7 @@ class C {
}
if (true) break else <!NOT_A_LOOP_LABEL!>break@l<!>
}
a.<!INAPPLICABLE_CANDIDATE!>compareTo<!>("2")
a.<!UNSAFE_CALL!>compareTo<!>("2")
}
fun twoLabelsOnLoop() {

2
compiler/testData/diagnostics/tests/Nullability.fir.kt vendored
View File

@@ -158,7 +158,7 @@ fun test() {
fun f(out : String?) {
out?.get(0)
out.<!INAPPLICABLE_CANDIDATE!>get<!>(0)
out.<!UNSAFE_CALL!>get<!>(0)
if (out != null) else return;
out.get(0)
}

8
compiler/testData/diagnostics/tests/collectionLiterals/basicCollectionLiterals.fir.kt vendored
View File

@@ -14,11 +14,11 @@ fun test() {
}
fun check() {
[1, 2] <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Array<Int>>() }
[""] <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Array<String>>() }
[1, 2] <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Array<Int>>() }
[""] <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Array<String>>() }
val f: IntArray = [1]
[f] <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Array<IntArray>>() }
[f] <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Array<IntArray>>() }
[1, ""] <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Array<Any>>() }
[1, ""] <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Array<Any>>() }
}

6
compiler/testData/diagnostics/tests/controlStructures/ForLoopWithExtensionIteratorOnNullable.fir.kt vendored
View File

@@ -7,9 +7,9 @@ operator fun <K> Container<K>.iterator(): Iterator<K> = null!!
fun test() {
val container: Container<String>? = null
// Error
container.<!INAPPLICABLE_CANDIDATE!>iterator<!>()
container.<!UNSAFE_CALL!>iterator<!>()
// for extension iterator, this code compiles, but should not
<!INAPPLICABLE_CANDIDATE!>for (s in container) {}<!>
<!UNSAFE_CALL!>for (s in container) {}<!>
}
class OtherContainer<K>(val k: K) {
operator fun iterator(): Iterator<K> = null!!
@@ -18,5 +18,5 @@ class OtherContainer<K>(val k: K) {
fun test2() {
val other: OtherContainer<String>? = null
// Error
<!INAPPLICABLE_CANDIDATE!>for (s in other) {}<!>
<!UNSAFE_CALL!>for (s in other) {}<!>
}

2
compiler/testData/diagnostics/tests/controlStructures/forLoopWithNullableRange.fir.kt vendored
View File

@@ -8,7 +8,7 @@ class It {
}
fun test(c: Coll?) {
<!INAPPLICABLE_CANDIDATE!>for (x in c) {}<!>
<!UNSAFE_CALL!>for (x in c) {}<!>
if (c != null) {
for(x in c) {}

2
compiler/testData/diagnostics/tests/controlStructures/forWithNullableIterator.fir.kt vendored
View File

@@ -8,5 +8,5 @@ class It {
}
fun test() {
<!INAPPLICABLE_CANDIDATE, INAPPLICABLE_CANDIDATE!>for (x in Coll()) {}<!>
<!UNSAFE_CALL, UNSAFE_CALL!>for (x in Coll()) {}<!>
}

4
compiler/testData/diagnostics/tests/dataClasses/extensionComponentsOnNullable.fir.kt vendored
View File

@@ -8,7 +8,7 @@ operator fun <T> Data<T>.component2() = y
fun foo(): Int {
val d: Data<Int>? = null
// An error must be here
val (<!INAPPLICABLE_CANDIDATE!>x<!>, <!INAPPLICABLE_CANDIDATE!>y<!>) = d
val (x, y) = <!COMPONENT_FUNCTION_ON_NULLABLE, COMPONENT_FUNCTION_ON_NULLABLE!>d<!>
return x + y
}
@@ -17,6 +17,6 @@ data class NormalData<T>(val x: T, val y: T)
fun bar(): Int {
val d: NormalData<Int>? = null
// An error must be here
val (<!INAPPLICABLE_CANDIDATE!>x<!>, <!INAPPLICABLE_CANDIDATE!>y<!>) = d
val (x, y) = <!COMPONENT_FUNCTION_ON_NULLABLE, COMPONENT_FUNCTION_ON_NULLABLE!>d<!>
return x + y
}

2
compiler/testData/diagnostics/tests/dataFlow/assignment/uninitializedValNullability.fir.kt vendored
View File

@@ -10,6 +10,6 @@ fun test(a: Any?, flag: Boolean, x: Any?) {
}
else {
b = x
b.<!INAPPLICABLE_CANDIDATE!>hashCode<!>()
b.<!UNSAFE_CALL!>hashCode<!>()
}
}

6
compiler/testData/diagnostics/tests/dataFlowInfoTraversal/UnaryExpression.fir.kt vendored
View File

@@ -4,11 +4,11 @@ fun baz(b: Boolean): Boolean = !b
fun foo() {
val x: Int? = null
bar(<!INAPPLICABLE_CANDIDATE!>-<!>x)
bar(<!UNSAFE_CALL!>-<!>x)
if (x != null) bar(-x)
bar(<!INAPPLICABLE_CANDIDATE!>-<!>x)
bar(<!UNSAFE_CALL!>-<!>x)
val b: Boolean? = null
baz(<!INAPPLICABLE_CANDIDATE!>!<!>b)
baz(<!UNSAFE_CALL!>!<!>b)
if (b != null) baz(!b)
}

2
compiler/testData/diagnostics/tests/declarationChecks/MultiDeclarationErrors.fir.kt vendored
View File

@@ -11,7 +11,7 @@ class MyClass2 {}
<!CONFLICTING_OVERLOADS!>fun MyClass2.component1()<!> = 1.3
fun test(mc1: MyClass, mc2: MyClass2) {
val (<!INAPPLICABLE_CANDIDATE!>a<!>, b) = <!COMPONENT_FUNCTION_MISSING!>mc1<!>
val (a, b) = <!COMPONENT_FUNCTION_MISSING!>mc1<!>
val (c) = mc2
//a,b,c are error types

2
compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.fir.kt vendored
View File

@@ -5,7 +5,7 @@ fun foo(block: () -> (() -> Int)) {}
fun test() {
val x = <!EXPRESSION_REQUIRED!>fun named1(x: Int): Int { return 1 }<!>
x <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Function1<Int, Int>>() }
x <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Function1<Int, Int>>() }
foo { fun named2(): Int {return 1} }
foo({ fun named3() = 1 })

2
compiler/testData/diagnostics/tests/extensions/ExtensionFunctions.fir.kt vendored
View File

@@ -64,7 +64,7 @@ import outer.*
command.foo
command.<!INAPPLICABLE_CANDIDATE!>equals<!>(null)
command.<!UNSAFE_CALL!>equals<!>(null)
command?.equals(null)
command.equals1(null)
command?.equals1(null)

6
compiler/testData/diagnostics/tests/extensions/kt1875.fir.kt vendored
View File

@@ -9,13 +9,13 @@ interface T {
}
fun test(t: T) {
t.<!INAPPLICABLE_CANDIDATE!>f<!>(1) //unsafe call error
t.<!UNSAFE_CALL!>f<!>(1) //unsafe call error
t.f?.invoke(1)
}
fun test1(t: T?) {
t.<!UNRESOLVED_REFERENCE!>f<!>(1) // todo resolve f as value and report UNSAFE_CALL
t?.<!INAPPLICABLE_CANDIDATE!>f<!>(1)
t.<!INAPPLICABLE_CANDIDATE!>f<!>?.invoke(1)
t?.<!UNSAFE_CALL!>f<!>(1)
t.<!UNSAFE_CALL!>f<!>?.invoke(1)
t?.f?.invoke(1)
}

6
compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver.fir.kt vendored
View File

@@ -8,7 +8,7 @@ fun <R> List<R>.a() {}
fun test1(i: Int?) {
1.<!INAPPLICABLE_CANDIDATE!>a<!>()
i.<!INAPPLICABLE_CANDIDATE!>a<!>()
i.<!UNSAFE_CALL!>a<!>()
}
fun <R> test2(c: Collection<R>) {
@@ -19,7 +19,7 @@ fun Int.foo() {}
fun test3(s: String?) {
"".<!INAPPLICABLE_CANDIDATE!>foo<!>()
s.<!INAPPLICABLE_CANDIDATE!>foo<!>()
s.<!UNSAFE_CALL!>foo<!>()
"".<!INAPPLICABLE_CANDIDATE!>foo<!>(1)
s.<!INAPPLICABLE_CANDIDATE!>foo<!>("a")
}
@@ -52,5 +52,5 @@ fun test7(l: List<String?>) {
}
fun test8(l: List<Any>?) {
l.<!INAPPLICABLE_CANDIDATE!>b<!>()
l.<!UNSAFE_CALL!>b<!>()
}

12
compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/complexInference.fir.kt vendored
View File

@@ -24,24 +24,24 @@ fun bar(aInstance: A, bInstance: B) {
foo(bInstance) {
(a, b): A, (c, d) ->
<!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
<!UNRESOLVED_REFERENCE!>b<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
<!UNRESOLVED_REFERENCE!>a<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
<!UNRESOLVED_REFERENCE!>b<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
c checkType { _<Double>() }
d checkType { _<Short>() }
}
foo(bInstance) {
(a, b), (c, d) ->
<!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
<!UNRESOLVED_REFERENCE!>b<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
<!UNRESOLVED_REFERENCE!>a<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
<!UNRESOLVED_REFERENCE!>b<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
c checkType { _<Double>() }
d checkType { _<Short>() }
}
foo<A, B>(bInstance) {
(a, b), (c, d) ->
<!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
<!UNRESOLVED_REFERENCE!>b<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
<!UNRESOLVED_REFERENCE!>a<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
<!UNRESOLVED_REFERENCE!>b<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
c checkType { _<Double>() }
d checkType { _<Short>() }
}

2
compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/redeclaration.fir.kt vendored
View File

@@ -23,7 +23,7 @@ fun bar() {
}
foo { (a, b), (c, b) ->
<!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
<!UNRESOLVED_REFERENCE!>a<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
b checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
c checkType { <!INAPPLICABLE_CANDIDATE!>_<!><B>() }
}

4
compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/simple.fir.kt vendored
View File

@@ -36,8 +36,8 @@ fun bar() {
}
foobar { (a, b), (c, d) ->
<!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
<!UNRESOLVED_REFERENCE!>b<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
<!UNRESOLVED_REFERENCE!>a<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
<!UNRESOLVED_REFERENCE!>b<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
c checkType { _<Double>() }
d checkType { _<Short>() }
}

4
compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/unusedParameters.fir.kt vendored
View File

@@ -32,12 +32,12 @@ fun bar() {
}
foobar { (a, b), (c, d) ->
<!UNRESOLVED_REFERENCE!>a<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
<!UNRESOLVED_REFERENCE!>a<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
d checkType { _<Short>() }
}
foobar { (a, b), (c, d) ->
<!UNRESOLVED_REFERENCE!>b<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
<!UNRESOLVED_REFERENCE!>b<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
c checkType { _<Double>() }
}
}

4
compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClasses.fir.kt vendored
View File

@@ -20,7 +20,7 @@ class A : Outer<Double, Short>() {
fun foo() {
Derived().foo() checkType { _<Outer<String, Int>.Inner<Char>>() }
Derived().baz() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Map<Char, String>>() }
Derived().baz() <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Map<Char, String>>() }
A.B().bar() checkType { _<Outer<Float, Long>.Inner<String>>() }
A.B().x() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Map<String, Float>>() }
A.B().x() <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Map<String, Float>>() }
}

4
compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocal.fir.kt vendored
View File

@@ -43,7 +43,7 @@ fun test() {
x = foobar<String>()
x().foo().a() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><A<String, Double, Short, Long>>() }
x().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><A<String, Double, Short, Char>>() }
x().bar() <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><A<String, Double, Short, Char>>() }
x = foobar<Int>()
@@ -51,5 +51,5 @@ fun test() {
y = noParameters()
y().foo().a() checkType { _<A<Any, Double, Short, Long>>() }
y().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><A<Any, Double, Short, Char>>() }
y().bar() <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><A<Any, Double, Short, Char>>() }
}

4
compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocalInsideInner.fir.kt vendored
View File

@@ -44,7 +44,7 @@ class Outer<T> {
x = foobar<String>()
x().foo().a() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><A<T, F, String, Double, Short, Long>>() }
x().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><A<T, F, String, Double, Short, Char>>() }
x().bar() <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><A<T, F, String, Double, Short, Char>>() }
x = foobar<Int>()
x = z.foobar<String>()
@@ -53,7 +53,7 @@ class Outer<T> {
y = noParameters()
y().foo().a() checkType { _<A<T, F, Any, Double, Short, Long>>() }
y().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><A<T, F, Any, Double, Short, Char>>() }
y().bar() <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><A<T, F, Any, Double, Short, Char>>() }
}
}
}

2
compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesTransitive.fir.kt vendored
View File

@@ -15,5 +15,5 @@ class Derived : BaseDerived2<Int>() {
fun foo() {
Derived().foo() checkType { _<Outer<Int, String>.Inner<Char>>() }
Derived().baz() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Map<Char, Int>>() }
Derived().baz() <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Map<Char, Int>>() }
}

8
compiler/testData/diagnostics/tests/inference/completion/lambdaWithVariableAndNothing.fir.kt vendored
View File

@@ -23,7 +23,7 @@ fun testNoSmartCast1(s: String?) {
if (s != null) ""
else noSmartCast1(null) { "" }
)
s.<!INAPPLICABLE_CANDIDATE!>length<!>
s.<!UNSAFE_CALL!>length<!>
}
fun testNoSmartCast2(s: String?) {
@@ -31,7 +31,7 @@ fun testNoSmartCast2(s: String?) {
if (s != null) ( {""} )
else noSmartCast2(null) { "" }
)
s.<!INAPPLICABLE_CANDIDATE!>length<!>
s.<!UNSAFE_CALL!>length<!>
}
fun testNoSmartCast3(s: String?) {
@@ -39,7 +39,7 @@ fun testNoSmartCast3(s: String?) {
if (s != null) ""
else noSmartCast3(null) { "" }
)
s.<!INAPPLICABLE_CANDIDATE!>length<!>
s.<!UNSAFE_CALL!>length<!>
}
// KT-36069
@@ -48,5 +48,5 @@ fun testNoSmartCast4(s: String?) {
if (s != null) ( {""} )
else noSmartCast4(null) { "" }
)
s.<!INAPPLICABLE_CANDIDATE!>length<!>
s.<!UNSAFE_CALL!>length<!>
}

6
compiler/testData/diagnostics/tests/inference/regressions/kt2842.fir.kt vendored
View File

@@ -3,14 +3,14 @@ package c
interface A<T>
fun test(a: A<Int>?) {
a.<!INAPPLICABLE_CANDIDATE!>foo<!>() //no error
a.<!UNSAFE_CALL!>foo<!>() //no error
}
fun <R> A<R>.foo() {}
//------------
fun test(nullabilityInfoMap: Map<Int, Any>?) {
nullabilityInfoMap.<!INAPPLICABLE_CANDIDATE!>iterator<!>() //no error
nullabilityInfoMap.<!UNSAFE_CALL!>iterator<!>() //no error
}
//resolves to
@@ -20,7 +20,7 @@ public fun <K,V> Map<K,V>.iterator(): Iterator<Map.Entry<K,V>> {}
//-------------
fun foo() : Boolean {
val nullableList = getNullableList()
return nullableList.<!INAPPLICABLE_CANDIDATE!>contains<!>("")
return nullableList.<!UNSAFE_CALL!>contains<!>("")
}

8
compiler/testData/diagnostics/tests/j+k/properties/fieldPropertyOverloads.fir.kt vendored
View File

@@ -19,9 +19,9 @@ public abstract class CollectionWithSize implements java.util.Collection<String>
// FILE: main.kt
fun main(c: CollectionWithSize) {
CompressionType.ZIP.<!AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
c.<!AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
CompressionType.ZIP.<!AMBIGUITY!>name<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
c.<!AMBIGUITY!>size<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
<!UNRESOLVED_REFERENCE!>CompressionType.ZIP::name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
<!UNRESOLVED_REFERENCE!>c::size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
<!UNRESOLVED_REFERENCE!>CompressionType.ZIP::name<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
<!UNRESOLVED_REFERENCE!>c::size<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
}

8
compiler/testData/diagnostics/tests/j+k/properties/fieldPropertyOverloadsDisabled.fir.kt vendored
View File

@@ -20,9 +20,9 @@ public abstract class CollectionWithSize implements java.util.Collection<String>
// FILE: main.kt
fun main(c: CollectionWithSize) {
CompressionType.ZIP.<!AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
c.<!AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
CompressionType.ZIP.<!AMBIGUITY!>name<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
c.<!AMBIGUITY!>size<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
<!UNRESOLVED_REFERENCE!>CompressionType.ZIP::name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
<!UNRESOLVED_REFERENCE!>c::size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
<!UNRESOLVED_REFERENCE!>CompressionType.ZIP::name<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
<!UNRESOLVED_REFERENCE!>c::size<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
}

8
compiler/testData/diagnostics/tests/j+k/properties/fieldPropertyOverloadsNI.fir.kt vendored
View File

@@ -19,9 +19,9 @@ public abstract class CollectionWithSize implements java.util.Collection<String>
// FILE: main.kt
fun main(c: CollectionWithSize) {
CompressionType.ZIP.<!AMBIGUITY!>name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
c.<!AMBIGUITY!>size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
CompressionType.ZIP.<!AMBIGUITY!>name<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Double>() }
c.<!AMBIGUITY!>size<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
<!UNRESOLVED_REFERENCE!>CompressionType.ZIP::name<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
<!UNRESOLVED_REFERENCE!>c::size<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
<!UNRESOLVED_REFERENCE!>CompressionType.ZIP::name<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<Double>>() }
<!UNRESOLVED_REFERENCE!>c::size<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><kotlin.reflect.KProperty0<String>>() }
}

4
compiler/testData/diagnostics/tests/j+k/sam/enhancedSamConstructor.fir.kt vendored
View File

@@ -17,12 +17,12 @@ public interface J2 extends J {
// FILE: main.kt
fun main() {
<!INAPPLICABLE_CANDIDATE!>J<!> { s: String -> s} // should be prohibited, because SAM value parameter has nullable type
J { "" + it.<!INAPPLICABLE_CANDIDATE!>length<!> }
J { "" + it.<!UNSAFE_CALL!>length<!> }
J { null }
J { it?.length?.toString() }
<!INAPPLICABLE_CANDIDATE!>J2<!> { s: String -> s}
J2 { "" + it.<!INAPPLICABLE_CANDIDATE!>length<!> }
J2 { "" + it.<!UNSAFE_CALL!>length<!> }
J2 { null }
J2 { it?.length?.toString() }
}

4
compiler/testData/diagnostics/tests/j+k/selectMoreSpecific.fir.kt vendored
View File

@@ -11,6 +11,6 @@ public class A {
// FILE: main.kt
fun foo(a: A) {
a.<!AMBIGUITY!>foo<!>() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
A.<!AMBIGUITY!>bar<!>() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
a.<!AMBIGUITY!>foo<!>() <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
A.<!AMBIGUITY!>bar<!>() <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
}

26
compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/InfixCallNullability.fir.kt vendored
View File

@@ -12,21 +12,21 @@ fun test(x : Int?, a : A?) {
x.<!NONE_APPLICABLE!>plus<!>(1)
x?.plus(1)
x <!NONE_APPLICABLE!>+<!> 1
<!INAPPLICABLE_CANDIDATE!>-<!>x
x.<!INAPPLICABLE_CANDIDATE!>unaryMinus<!>()
<!UNSAFE_CALL!>-<!>x
x.<!UNSAFE_CALL!>unaryMinus<!>()
x?.unaryMinus()
a.<!INAPPLICABLE_CANDIDATE!>plus<!>(1)
a.<!UNSAFE_CALL!>plus<!>(1)
a?.plus(1)
a <!INAPPLICABLE_CANDIDATE!>plus<!> 1
a <!INAPPLICABLE_CANDIDATE!>+<!> 1
<!INAPPLICABLE_CANDIDATE!>-<!>a
a.<!INAPPLICABLE_CANDIDATE!>unaryMinus<!>()
a <!UNSAFE_CALL!>plus<!> 1
a <!UNSAFE_CALL!>+<!> 1
<!UNSAFE_CALL!>-<!>a
a.<!UNSAFE_CALL!>unaryMinus<!>()
a?.unaryMinus()
a.<!INAPPLICABLE_CANDIDATE!>div<!>(1)
a <!INAPPLICABLE_CANDIDATE!>/<!> 1
a <!INAPPLICABLE_CANDIDATE!>div<!> 1
a.<!UNSAFE_CALL!>div<!>(1)
a <!UNSAFE_CALL!>/<!> 1
a <!UNSAFE_CALL!>div<!> 1
a?.div(1)
a.times(1)
@@ -34,8 +34,8 @@ fun test(x : Int?, a : A?) {
a times 1
a?.times(1)
1 <!INAPPLICABLE_CANDIDATE!>in<!> a
a <!INAPPLICABLE_CANDIDATE!>contains<!> 1
a.<!INAPPLICABLE_CANDIDATE!>contains<!>(1)
1 <!UNSAFE_CALL!>in<!> a
a <!UNSAFE_CALL!>contains<!> 1
a.<!UNSAFE_CALL!>contains<!>(1)
a?.contains(1)
}

6
compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/QualifiedExpressionNullability.fir.kt vendored
View File

@@ -7,7 +7,7 @@ fun main() {
val x: Foo? = null
val y: Foo? = null
x.<!INAPPLICABLE_CANDIDATE!>foo<!>(y)
x.<!UNSAFE_CALL!>foo<!>(y)
x!!.<!INAPPLICABLE_CANDIDATE!>foo<!>(y)
x.foo(y!!)
x!!.foo(y!!)
@@ -16,8 +16,8 @@ fun main() {
val b: Foo? = null
val c: Foo? = null
a.<!INAPPLICABLE_CANDIDATE!>foo<!>(b.<!INAPPLICABLE_CANDIDATE!>foo<!>(c))
a!!.foo(b.<!INAPPLICABLE_CANDIDATE!>foo<!>(c))
a.<!UNSAFE_CALL!>foo<!>(b.<!UNSAFE_CALL!>foo<!>(c))
a!!.foo(b.<!UNSAFE_CALL!>foo<!>(c))
a.foo(b!!.<!INAPPLICABLE_CANDIDATE!>foo<!>(c))
a!!.foo(b!!.<!INAPPLICABLE_CANDIDATE!>foo<!>(c))
a.foo(b.foo(c!!))

12
compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/ReceiverNullability.fir.kt vendored
View File

@@ -6,8 +6,8 @@ fun A.bar() {}
fun A?.buzz() {}
fun test(a : A?) {
a.<!INAPPLICABLE_CANDIDATE!>foo<!>() // error
a.<!INAPPLICABLE_CANDIDATE!>bar<!>() // error
a.<!UNSAFE_CALL!>foo<!>() // error
a.<!UNSAFE_CALL!>bar<!>() // error
a.buzz()
a?.foo()
@@ -30,12 +30,12 @@ fun A.test2() {
}
fun A?.test3() {
<!INAPPLICABLE_CANDIDATE!>foo<!>() // error
<!INAPPLICABLE_CANDIDATE!>bar<!>() // error
<!UNSAFE_CALL!>foo<!>() // error
<!UNSAFE_CALL!>bar<!>() // error
buzz()
this.<!INAPPLICABLE_CANDIDATE!>foo<!>() // error
this.<!INAPPLICABLE_CANDIDATE!>bar<!>() // error
this.<!UNSAFE_CALL!>foo<!>() // error
this.<!UNSAFE_CALL!>bar<!>() // error
this.buzz()
this?.foo()

2
compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt1270.fir.kt vendored
View File

@@ -5,7 +5,7 @@ package kt1270
fun foo() {
val sc = java.util.HashMap<String, SomeClass>()[""]
val value = sc.<!INAPPLICABLE_CANDIDATE!>value<!>
val value = sc.<!UNSAFE_CALL!>value<!>
}
private class SomeClass() {

2
compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2125.fir.kt vendored
View File

@@ -5,7 +5,7 @@ package e
fun main() {
val compareTo = 1
val s: String? = null
s.<!INAPPLICABLE_CANDIDATE!>compareTo<!>("")
s.<!UNSAFE_CALL!>compareTo<!>("")
val bar = 2
s.<!UNRESOLVED_REFERENCE!>bar<!>()

2
compiler/testData/diagnostics/tests/platformTypes/noAnnotationInClassPath.fir.kt vendored
View File

@@ -13,5 +13,5 @@ public class B {
// FILE: main.kt
fun test() {
B.bar() { it.<!INAPPLICABLE_CANDIDATE!>hashCode<!>() > 0 }
B.bar() { it.<!UNSAFE_CALL!>hashCode<!>() > 0 }
}

4
compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/arithmetic.fir.kt vendored
View File

@@ -22,11 +22,11 @@ fun test() {
var platformJ = J.staticJ
+platformNN
<!INAPPLICABLE_CANDIDATE!>+<!>platformN
<!UNSAFE_CALL!>+<!>platformN
+platformJ
++platformNN
<!INAPPLICABLE_CANDIDATE!>++<!>platformN
<!UNSAFE_CALL!>++<!>platformN
++platformJ
platformNN++

4
compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/array.fir.kt vendored
View File

@@ -21,11 +21,11 @@ fun test() {
val platformJ = J.staticJ
platformNN[0]
<!INAPPLICABLE_CANDIDATE!>platformN[0]<!>
<!UNSAFE_CALL!>platformN[0]<!>
platformJ[0]
platformNN[0] = 1
<!INAPPLICABLE_CANDIDATE!>platformN[0] = 1<!>
<!UNSAFE_CALL!>platformN[0] = 1<!>
platformJ[0] = 1
}

2
compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/conditions.fir.kt vendored
View File

@@ -43,6 +43,6 @@ fun test() {
platformJ || false
!platformNN
<!INAPPLICABLE_CANDIDATE!>!<!>platformN
<!UNSAFE_CALL!>!<!>platformN
!platformJ
}

2
compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegatedProperties.fir.kt vendored
View File

@@ -19,5 +19,5 @@ public class J {
// FILE: k.kt
var A by J.staticNN
var B by <!INAPPLICABLE_CANDIDATE!>J.staticN<!>
var B by <!UNSAFE_CALL!>J.staticN<!>
var C by J.staticJ

4
compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/derefenceExtension.fir.kt vendored
View File

@@ -23,14 +23,14 @@ fun test() {
val platformJ = J.staticJ
platformNN.foo()
platformN.<!INAPPLICABLE_CANDIDATE!>foo<!>()
platformN.<!UNSAFE_CALL!>foo<!>()
platformJ.foo()
with(platformNN) {
foo()
}
with(platformN) {
<!INAPPLICABLE_CANDIDATE!>foo<!>()
<!UNSAFE_CALL!>foo<!>()
}
with(platformJ) {
foo()

4
compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/derefenceMember.fir.kt vendored
View File

@@ -25,14 +25,14 @@ fun test() {
val platformJ = J.staticJ
platformNN.foo()
platformN.<!INAPPLICABLE_CANDIDATE!>foo<!>()
platformN.<!UNSAFE_CALL!>foo<!>()
platformJ.foo()
with(platformNN) {
foo()
}
with(platformN) {
<!INAPPLICABLE_CANDIDATE!>foo<!>()
<!UNSAFE_CALL!>foo<!>()
}
with(platformJ) {
foo()

2
compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/for.fir.kt vendored
View File

@@ -22,7 +22,7 @@ fun test() {
val platformJ = J.staticJ
for (x in platformNN) {}
<!INAPPLICABLE_CANDIDATE!>for (x in platformN) {}<!>
<!UNSAFE_CALL!>for (x in platformN) {}<!>
for (x in platformJ) {}
}

2
compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/invoke.fir.kt vendored
View File

@@ -18,6 +18,6 @@ public class J {
fun test() {
J.staticNN()
J.<!INAPPLICABLE_CANDIDATE!>staticN<!>()
J.<!UNSAFE_CALL!>staticN<!>()
J.staticJ()
}

2
compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/kt6829.fir.kt vendored
View File

@@ -16,7 +16,7 @@ public class J {
fun foo(collection: Collection<J>) {
val mapped = collection.map { it.method() }
mapped[0].<!INAPPLICABLE_CANDIDATE!>length<!>
mapped[0].<!UNSAFE_CALL!>length<!>
}
public fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R> {

32
compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/multiDeclaration.fir.kt vendored
View File

@@ -1,32 +0,0 @@
// !DIAGNOSTICS: -UNUSED_VARIABLE
// FILE: J.java
import org.jetbrains.annotations.*;
public class J {
public interface Multi {
String component1();
String component2();
}
@NotNull
public static Multi staticNN;
@Nullable
public static Multi staticN;
public static Multi staticJ;
}
// FILE: k.kt
fun test() {
// @NotNull platform type
val platformNN = J.staticNN
// @Nullable platform type
val platformN = J.staticN
// platform type with no annotation
val platformJ = J.staticJ
val (a1, b1) = platformNN
val (<!INAPPLICABLE_CANDIDATE!>a2<!>, <!INAPPLICABLE_CANDIDATE!>b2<!>) = platformN
val (a3, b3) = platformJ
}

1
compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/multiDeclaration.kt vendored
View File

@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !DIAGNOSTICS: -UNUSED_VARIABLE
// FILE: J.java

4
compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/primitiveArray.fir.kt vendored
View File

@@ -21,11 +21,11 @@ fun test() {
val platformJ = J.staticJ
platformNN[0]
<!INAPPLICABLE_CANDIDATE!>platformN[0]<!>
<!UNSAFE_CALL!>platformN[0]<!>
platformJ[0]
platformNN[0] = 1
<!INAPPLICABLE_CANDIDATE!>platformN[0] = 1<!>
<!UNSAFE_CALL!>platformN[0] = 1<!>
platformJ[0] = 1
}

4
compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/overriddenExtensions.fir.kt vendored
View File

@@ -8,8 +8,8 @@ class E : B1() {
fun baz() {
val x: String? = ""
x.<!INAPPLICABLE_CANDIDATE!>foo<!>(x)
x.<!INAPPLICABLE_CANDIDATE!>foo<!>("")
x.<!UNSAFE_CALL!>foo<!>(x)
x.<!UNSAFE_CALL!>foo<!>("")
x.<!INAPPLICABLE_CANDIDATE!>bar<!>(x)
x.bar("")
}

2
compiler/testData/diagnostics/tests/properties/inferenceFromGetters/primaryConstructorParameter.fir.kt vendored
View File

@@ -19,5 +19,5 @@ class C(p: Any, val v: Any) {
var test5
get() { return <!UNRESOLVED_REFERENCE!>p<!> }
set(nv) { <!UNRESOLVED_REFERENCE!>p<!>.<!INAPPLICABLE_CANDIDATE!>let<!> {} }
set(nv) { <!UNRESOLVED_REFERENCE!>p<!>.<!UNSAFE_CALL!>let<!> {} }
}

2
compiler/testData/diagnostics/tests/regressions/kt12898.fir.kt vendored
View File

@@ -10,7 +10,7 @@ class C(override val t: Any?) : B<Any?, Any>
fun f(b: B<*, Any>) {
val y = b.t
if (y is String?) {
y.<!INAPPLICABLE_CANDIDATE!>length<!>
y.<!UNSAFE_CALL!>length<!>
}
}

2
compiler/testData/diagnostics/tests/regressions/kt282.fir.kt vendored
View File

@@ -14,6 +14,6 @@ fun f(): Unit {
val i : Int? = null
i <!NONE_APPLICABLE!>+<!> 1
set + 1
1 <!INAPPLICABLE_CANDIDATE!>in<!> set
1 <!UNSAFE_CALL!>in<!> set
1 in 2
}

2
compiler/testData/diagnostics/tests/regressions/kt557.fir.kt vendored
View File

@@ -8,5 +8,5 @@ fun Array<String>.length() : Int {
}
fun test(array : Array<String?>?) {
array?.sure<Array<String?>>().<!INAPPLICABLE_CANDIDATE!>length<!>()
array?.sure<Array<String?>>().<!UNSAFE_CALL!>length<!>()
}

4
compiler/testData/diagnostics/tests/resolve/invoke/errors/unsafeCallWithInvoke.fir.kt vendored
View File

@@ -4,7 +4,7 @@
operator fun String.invoke(i: Int) {}
fun foo(s: String?) {
<!INAPPLICABLE_CANDIDATE!>s<!>(1)
<!UNSAFE_CALL!>s<!>(1)
<!INAPPLICABLE_CANDIDATE!>(s ?: null)(1)<!>
<!UNSAFE_CALL!>(s ?: null)(1)<!>
}

12
compiler/testData/diagnostics/tests/resolve/invoke/implicitInvokeAfterSafeCall.fir.kt vendored
View File

@@ -12,7 +12,7 @@ class Another1 {
fun Another1.main(x: Bar1<String>?) {
x?.value {}
x?.value.<!INAPPLICABLE_CANDIDATE!>invoke<!>({})
x?.value.<!UNSAFE_CALL!>invoke<!>({})
}
// Test case 2: additional receiver, non-generic invoke
@@ -26,7 +26,7 @@ class Another2 {
fun Another2.main(x: Bar2<String>?) {
x?.value(1)
x?.value.<!INAPPLICABLE_CANDIDATE!>invoke<!>(1)
x?.value.<!UNSAFE_CALL!>invoke<!>(1)
}
// Test case 3: additional generic receiver, generic invoke
@@ -40,7 +40,7 @@ class Another3<T> {
fun <K> Another3<K>.main(x: Bar3<K>?) {
x?.value(1)
x?.value.<!INAPPLICABLE_CANDIDATE!>invoke<!>(1)
x?.value.<!UNSAFE_CALL!>invoke<!>(1)
}
// Test case 4: additional receiver, generic invoke with nullable receiver
@@ -68,7 +68,7 @@ class Another5 {
fun Another5.main(x: Bar5?) {
x?.value {}
x?.value.<!INAPPLICABLE_CANDIDATE!>invoke<!>({})
x?.value.<!UNSAFE_CALL!>invoke<!>({})
}
// Test case 6: top-level generic invoke
@@ -96,7 +96,7 @@ operator fun <T> Foo7<T>.invoke(x: Int) {}
fun Another7.main(x: Bar7<String>?) {
x?.value(1)
x?.value.<!INAPPLICABLE_CANDIDATE!>invoke<!>(1)
x?.value.<!UNSAFE_CALL!>invoke<!>(1)
}
// Test case 8: top-level non-generic invoke
@@ -136,5 +136,5 @@ class Another10 {
fun Another10.main(x: Bar10<String>?) {
x?.value {}
x?.value.<!INAPPLICABLE_CANDIDATE!>invoke<!>({})
x?.value.<!UNSAFE_CALL!>invoke<!>({})
}

4
compiler/testData/diagnostics/tests/resolve/invoke/invokeAndSmartCast.fir.kt vendored
View File

@@ -7,8 +7,8 @@ fun test(a: A) {
(a.x)("")
}
"".<!UNRESOLVED_REFERENCE!>(a.x)()<!>
a.<!INAPPLICABLE_CANDIDATE!>x<!>("")
<!INAPPLICABLE_CANDIDATE!>(a.x)("")<!>
a.<!UNSAFE_CALL!>x<!>("")
<!UNSAFE_CALL!>(a.x)("")<!>
with("") {
a.<!INAPPLICABLE_CANDIDATE!>x<!>()

8
compiler/testData/diagnostics/tests/resolve/invoke/kt30695_2.fir.kt vendored
View File

@@ -14,7 +14,7 @@ class MemberInvokeOwner {
class Cls {
fun testImplicitReceiver() {
<!INAPPLICABLE_CANDIDATE!>nullableExtensionProperty<!>()
<!UNSAFE_CALL!>nullableExtensionProperty<!>()
}
}
@@ -30,7 +30,7 @@ fun testNullableReceiver(nullable: Cls?) {
}
fun testNotNullableReceiver(notNullable: Cls) {
notNullable.<!INAPPLICABLE_CANDIDATE!>nullableExtensionProperty<!>()
notNullable.<!UNSAFE_CALL!>nullableExtensionProperty<!>()
notNullable?.extensionProperty()
}
@@ -38,6 +38,6 @@ fun testFlexibleReceiver() {
val flexible = JavaClass.createFlexible()
flexible.extensionProperty()
flexible?.extensionProperty()
flexible.<!INAPPLICABLE_CANDIDATE!>nullableExtensionProperty<!>()
flexible?.<!INAPPLICABLE_CANDIDATE!>nullableExtensionProperty<!>()
flexible.<!UNSAFE_CALL!>nullableExtensionProperty<!>()
flexible?.<!UNSAFE_CALL!>nullableExtensionProperty<!>()
}

4
compiler/testData/diagnostics/tests/safeCall.fir.kt vendored
View File

@@ -1,7 +1,7 @@
// !WITH_NEW_INFERENCE
fun f(s: String, action: (String.() -> Unit)?) {
s.foo().bar().<!INAPPLICABLE_CANDIDATE!>action<!>()
s.foo().bar().<!UNSAFE_CALL!>action<!>()
}
fun String.foo() = ""
@@ -12,4 +12,4 @@ fun String.bar() = ""
val functions: Map<String, () -> Any> = TODO()
fun run(name: String) = <!INAPPLICABLE_CANDIDATE!>functions[name]()<!>
fun run(name: String) = <!UNSAFE_CALL!>functions[name]()<!>

4
compiler/testData/diagnostics/tests/samConversions/OverloadPriority.fir.kt vendored
View File

@@ -22,9 +22,9 @@ public interface J {
// FILE: 1.kt
fun test(j: J) {
j.<!AMBIGUITY!>foo<!>({ <!UNRESOLVED_REFERENCE!>it<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" }, "") <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
j.<!AMBIGUITY!>foo<!>({ <!UNRESOLVED_REFERENCE!>it<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" }, "") <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
j.<!AMBIGUITY!>bas<!>({ <!UNRESOLVED_REFERENCE!>it<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" }, "") <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
j.<!AMBIGUITY!>bas<!>({ <!UNRESOLVED_REFERENCE!>it<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" }, "") <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
// NI: TODO
j.bar { it checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" } checkType { _<Int>() }

4
compiler/testData/diagnostics/tests/samConversions/OverloadPriorityKT.fir.kt vendored
View File

@@ -21,9 +21,9 @@ interface K {
}
fun test(k: K) {
k.<!AMBIGUITY!>foo<!> { <!UNRESOLVED_REFERENCE!>it<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" } <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
k.<!AMBIGUITY!>foo<!> { <!UNRESOLVED_REFERENCE!>it<!> <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" } <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
k.<!AMBIGUITY!>bas<!> { <!UNRESOLVED_REFERENCE!>it<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { _<Any?>() }; "" } <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
k.<!AMBIGUITY!>bas<!> { <!UNRESOLVED_REFERENCE!>it<!> <!UNSAFE_CALL!>checkType<!> { _<Any?>() }; "" } <!UNSAFE_CALL!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
// NI: TODO
k.bar { it checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any>() }; "" } checkType { _<Int>() }

2
compiler/testData/diagnostics/tests/smartCasts/alwaysNull.fir.kt vendored
View File

@@ -3,7 +3,7 @@ fun foo(): String {
var s: String?
s = null
s?.length
s.<!INAPPLICABLE_CANDIDATE!>length<!>
s.<!UNSAFE_CALL!>length<!>
if (s == null) return s!!
var t: String? = "y"
if (t == null) t = "x"

6
compiler/testData/diagnostics/tests/smartCasts/castchecks/basicOff.fir.kt vendored
View File

@@ -13,7 +13,7 @@ fun g(a: SomeClass?) {
// 'a' can be cast to SomeSubClass
a.hashCode()
a.foo
(a as? SomeSubClass).<!INAPPLICABLE_CANDIDATE!>foo<!>
(a as? SomeSubClass).<!UNSAFE_CALL!>foo<!>
(a as SomeSubClass).foo
}
val b = (a as? SomeSubClass)?.foo
@@ -21,7 +21,7 @@ fun g(a: SomeClass?) {
// 'a' can be cast to SomeSubClass
a.hashCode()
a.foo
(a as? SomeSubClass).<!INAPPLICABLE_CANDIDATE!>foo<!>
(a as? SomeSubClass).<!UNSAFE_CALL!>foo<!>
(a as SomeSubClass).foo
}
val c = a as? SomeSubClass
@@ -29,7 +29,7 @@ fun g(a: SomeClass?) {
// 'a' and 'c' can be cast to SomeSubClass
a.hashCode()
a.foo
(a as? SomeSubClass).<!INAPPLICABLE_CANDIDATE!>foo<!>
(a as? SomeSubClass).<!UNSAFE_CALL!>foo<!>
c.hashCode()
c.foo
}

6
compiler/testData/diagnostics/tests/smartCasts/castchecks/basicOn.fir.kt vendored
View File

@@ -13,7 +13,7 @@ fun g(a: SomeClass?) {
// 'a' can be cast to SomeSubClass
a.hashCode()
a.foo
(a as? SomeSubClass).<!INAPPLICABLE_CANDIDATE!>foo<!>
(a as? SomeSubClass).<!UNSAFE_CALL!>foo<!>
(a as SomeSubClass).foo
}
val b = (a as? SomeSubClass)?.foo
@@ -21,7 +21,7 @@ fun g(a: SomeClass?) {
// 'a' can be cast to SomeSubClass
a.hashCode()
a.foo
(a as? SomeSubClass).<!INAPPLICABLE_CANDIDATE!>foo<!>
(a as? SomeSubClass).<!UNSAFE_CALL!>foo<!>
(a as SomeSubClass).foo
}
val c = a as? SomeSubClass
@@ -29,7 +29,7 @@ fun g(a: SomeClass?) {
// 'a' and 'c' can be cast to SomeSubClass
a.hashCode()
a.foo
(a as? SomeSubClass).<!INAPPLICABLE_CANDIDATE!>foo<!>
(a as? SomeSubClass).<!UNSAFE_CALL!>foo<!>
c.hashCode()
c.foo
}

18
compiler/testData/diagnostics/tests/smartCasts/castchecks/variables.fir.kt vendored
View File

@@ -18,18 +18,18 @@ fun g(a: SomeClass?) {
b = "Hello"
if (b != null) {
// 'a' cannot be cast to SomeSubClass!
a.<!INAPPLICABLE_CANDIDATE!>hashCode<!>()
a.<!UNSAFE_CALL!>hashCode<!>()
a.<!UNRESOLVED_REFERENCE!>foo<!>
(a as? SomeSubClass).<!INAPPLICABLE_CANDIDATE!>foo<!>
(a as? SomeSubClass).<!UNSAFE_CALL!>foo<!>
(a as SomeSubClass).foo
}
var c = a as? SomeSubClass
c = Impl
if (c != null) {
// 'a' cannot be cast to SomeSubClass
a.<!INAPPLICABLE_CANDIDATE!>hashCode<!>()
a.<!UNSAFE_CALL!>hashCode<!>()
a.<!UNRESOLVED_REFERENCE!>foo<!>
(a as? SomeSubClass).<!INAPPLICABLE_CANDIDATE!>foo<!>
(a as? SomeSubClass).<!UNSAFE_CALL!>foo<!>
c.hashCode()
c.foo
}
@@ -41,18 +41,18 @@ fun f(a: SomeClass?) {
if (aa as? SomeSubClass != null) {
aa = null
// 'aa' cannot be cast to SomeSubClass
aa.<!INAPPLICABLE_CANDIDATE!>hashCode<!>()
aa.<!UNSAFE_CALL!>hashCode<!>()
aa.<!UNRESOLVED_REFERENCE!>foo<!>
(aa as? SomeSubClass).<!INAPPLICABLE_CANDIDATE!>foo<!>
(aa as? SomeSubClass).<!UNSAFE_CALL!>foo<!>
(aa as SomeSubClass).foo
}
val b = (aa as? SomeSubClass)?.foo
aa = null
if (b != null) {
// 'aa' cannot be cast to SomeSubClass
aa.<!INAPPLICABLE_CANDIDATE!>hashCode<!>()
aa.<!UNSAFE_CALL!>hashCode<!>()
aa.<!UNRESOLVED_REFERENCE!>foo<!>
(aa as? SomeSubClass).<!INAPPLICABLE_CANDIDATE!>foo<!>
(aa as? SomeSubClass).<!UNSAFE_CALL!>foo<!>
(aa as SomeSubClass).foo
}
aa = a
@@ -61,7 +61,7 @@ fun f(a: SomeClass?) {
// 'c' can be cast to SomeSubClass
aa.hashCode()
aa.foo
(aa as? SomeSubClass).<!INAPPLICABLE_CANDIDATE!>foo<!>
(aa as? SomeSubClass).<!UNSAFE_CALL!>foo<!>
c.hashCode()
c.foo
}

24
compiler/testData/diagnostics/tests/smartCasts/comparisonUnderAnd.fir.kt vendored
View File

@@ -6,30 +6,30 @@ fun foo(x : String?, y : String?) {
y.length
}
else {
x.<!INAPPLICABLE_CANDIDATE!>length<!>
y.<!INAPPLICABLE_CANDIDATE!>length<!>
x.<!UNSAFE_CALL!>length<!>
y.<!UNSAFE_CALL!>length<!>
}
if (y != null || x == y) {
x.<!INAPPLICABLE_CANDIDATE!>length<!>
y.<!INAPPLICABLE_CANDIDATE!>length<!>
x.<!UNSAFE_CALL!>length<!>
y.<!UNSAFE_CALL!>length<!>
}
else {
// y == null but x != y
x.<!INAPPLICABLE_CANDIDATE!>length<!>
y.<!INAPPLICABLE_CANDIDATE!>length<!>
x.<!UNSAFE_CALL!>length<!>
y.<!UNSAFE_CALL!>length<!>
}
if (y == null && x != y) {
// y == null but x != y
x.<!INAPPLICABLE_CANDIDATE!>length<!>
y.<!INAPPLICABLE_CANDIDATE!>length<!>
x.<!UNSAFE_CALL!>length<!>
y.<!UNSAFE_CALL!>length<!>
}
else {
x.<!INAPPLICABLE_CANDIDATE!>length<!>
y.<!INAPPLICABLE_CANDIDATE!>length<!>
x.<!UNSAFE_CALL!>length<!>
y.<!UNSAFE_CALL!>length<!>
}
if (y == null || x != y) {
x.<!INAPPLICABLE_CANDIDATE!>length<!>
y.<!INAPPLICABLE_CANDIDATE!>length<!>
x.<!UNSAFE_CALL!>length<!>
y.<!UNSAFE_CALL!>length<!>
}
else {
// Both not null

12
compiler/testData/diagnostics/tests/smartCasts/complexComparison.fir.kt vendored
View File

@@ -3,21 +3,21 @@ fun foo(x: String?, y: String?, z: String?, w: String?) {
if (x != null && y != null && (x == z || y == z))
z.length
else
z.<!INAPPLICABLE_CANDIDATE!>length<!>
z.<!UNSAFE_CALL!>length<!>
if (x != null || y != null || (x != z && y != z))
z.<!INAPPLICABLE_CANDIDATE!>length<!>
z.<!UNSAFE_CALL!>length<!>
else
z.<!INAPPLICABLE_CANDIDATE!>length<!>
z.<!UNSAFE_CALL!>length<!>
if (x == null || y == null || (x != z && y != z))
z.<!INAPPLICABLE_CANDIDATE!>length<!>
z.<!UNSAFE_CALL!>length<!>
else
z.length
if (x != null && y == x && z == y && w == z)
w.length
else
w.<!INAPPLICABLE_CANDIDATE!>length<!>
w.<!UNSAFE_CALL!>length<!>
if ((x != null && y == x) || (z != null && y == z))
y.length
else
y.<!INAPPLICABLE_CANDIDATE!>length<!>
y.<!UNSAFE_CALL!>length<!>
}

20
compiler/testData/diagnostics/tests/smartCasts/complexConditionsWithExcl.fir.kt vendored
View File

@@ -1,26 +1,26 @@
fun foo(x: String?, y: String?, z: String?) {
if ((x!!.hashCode() == 0 || y!!.hashCode() == 1) && z!!.hashCode() == 2) {
x.length
y.<!INAPPLICABLE_CANDIDATE!>length<!>
y.<!UNSAFE_CALL!>length<!>
// condition is true => z!! after and is called
z.length
}
else {
x.length
y.<!INAPPLICABLE_CANDIDATE!>length<!>
z.<!INAPPLICABLE_CANDIDATE!>length<!>
y.<!UNSAFE_CALL!>length<!>
z.<!UNSAFE_CALL!>length<!>
}
// First element is always analyzed
x.length
var xx = y ?: z
if ((xx!!.hashCode() == 0 && y!!.hashCode() == 1) || z!!.hashCode() == 2) {
xx.length
y.<!INAPPLICABLE_CANDIDATE!>length<!>
z.<!INAPPLICABLE_CANDIDATE!>length<!>
y.<!UNSAFE_CALL!>length<!>
z.<!UNSAFE_CALL!>length<!>
}
else {
xx.length
y.<!INAPPLICABLE_CANDIDATE!>length<!>
y.<!UNSAFE_CALL!>length<!>
// condition is false => z!! after or is called
z.length
}
@@ -35,16 +35,16 @@ fun foo(x: String?, y: String?, z: String?) {
}
else {
xx.length
y.<!INAPPLICABLE_CANDIDATE!>length<!>
z.<!INAPPLICABLE_CANDIDATE!>length<!>
y.<!UNSAFE_CALL!>length<!>
z.<!UNSAFE_CALL!>length<!>
}
// First element is always analyzed
x.length
xx = y ?: z
if (xx!!.hashCode() == 0 || y!!.hashCode() == 1 || z!!.hashCode() == 2) {
xx.length
y.<!INAPPLICABLE_CANDIDATE!>length<!>
z.<!INAPPLICABLE_CANDIDATE!>length<!>
y.<!UNSAFE_CALL!>length<!>
z.<!UNSAFE_CALL!>length<!>
}
else {
// all three are called

8
compiler/testData/diagnostics/tests/smartCasts/elvis/basicOff.fir.kt vendored
View File

@@ -11,13 +11,13 @@ interface Order {
fun foo(o: Any) {
val order = o as? Order
if (order?.expired ?: false) {
order.<!INAPPLICABLE_CANDIDATE!>doSomething<!>()
order.<!UNSAFE_CALL!>doSomething<!>()
}
else {
}
if (order?.notExpired() ?: false) {
order.<!INAPPLICABLE_CANDIDATE!>doSomething<!>()
order.<!UNSAFE_CALL!>doSomething<!>()
}
}
@@ -39,12 +39,12 @@ fun bar(o: Any) {
fun baz(o: Boolean?) {
if (o ?: false) {
o.<!INAPPLICABLE_CANDIDATE!>hashCode<!>()
o.<!UNSAFE_CALL!>hashCode<!>()
}
if (o ?: true) {
}
else {
o.<!INAPPLICABLE_CANDIDATE!>hashCode<!>()
o.<!UNSAFE_CALL!>hashCode<!>()
}
}

8
compiler/testData/diagnostics/tests/smartCasts/elvis/basicOn.fir.kt vendored
View File

@@ -11,13 +11,13 @@ interface Order {
fun foo(o: Any) {
val order = o as? Order
if (order?.expired ?: false) {
order.<!INAPPLICABLE_CANDIDATE!>doSomething<!>()
order.<!UNSAFE_CALL!>doSomething<!>()
}
else {
}
if (order?.notExpired() ?: false) {
order.<!INAPPLICABLE_CANDIDATE!>doSomething<!>()
order.<!UNSAFE_CALL!>doSomething<!>()
}
}
@@ -39,12 +39,12 @@ fun bar(o: Any) {
fun baz(o: Boolean?) {
if (o ?: false) {
o.<!INAPPLICABLE_CANDIDATE!>hashCode<!>()
o.<!UNSAFE_CALL!>hashCode<!>()
}
if (o ?: true) {
}
else {
o.<!INAPPLICABLE_CANDIDATE!>hashCode<!>()
o.<!UNSAFE_CALL!>hashCode<!>()
}
}

2
compiler/testData/diagnostics/tests/smartCasts/elvisExclExcl.fir.kt vendored
View File

@@ -1,7 +1,7 @@
// Based on KT-9100
fun test(x: Any?, y: Any?): Any {
val z = x ?: y!!
y.<!INAPPLICABLE_CANDIDATE!>hashCode<!>()
y.<!UNSAFE_CALL!>hashCode<!>()
// !! / ?. is necessary here, because y!! above may not be executed
y?.hashCode()
y!!.hashCode()

2
compiler/testData/diagnostics/tests/smartCasts/elvisNothingRHS.fir.kt vendored
View File

@@ -4,7 +4,7 @@ class C {
fun test(a: C?, nn: () -> Nothing?) {
a ?: nn()
a.<!INAPPLICABLE_CANDIDATE!>foo<!>()
a.<!UNSAFE_CALL!>foo<!>()
a ?: return
a.foo()

2
compiler/testData/diagnostics/tests/smartCasts/enumEntryMembers_after.fir.kt vendored
View File

@@ -12,7 +12,7 @@ fun printMessages() {
Message.HELLO.text!!
Message.HELLO.text.length
Message.NOTHING.text.<!INAPPLICABLE_CANDIDATE!>length<!>
Message.NOTHING.text.<!UNSAFE_CALL!>length<!>
Message.NOTHING.text!!
Message.NOTHING.text.length

2
compiler/testData/diagnostics/tests/smartCasts/enumEntryMembers_before.fir.kt vendored
View File

@@ -12,7 +12,7 @@ fun printMessages() {
Message.HELLO.text!!
Message.HELLO.text.length
Message.NOTHING.text.<!INAPPLICABLE_CANDIDATE!>length<!>
Message.NOTHING.text.<!UNSAFE_CALL!>length<!>
Message.NOTHING.text!!
Message.NOTHING.text.length

8
compiler/testData/diagnostics/tests/smartCasts/exclUnderAnd.fir.kt vendored
View File

@@ -2,12 +2,12 @@ class D(val a: String, val b: Boolean)
fun foo(p: Boolean, v: D?): String {
if (p && v!!.b) v.a
else v.<!INAPPLICABLE_CANDIDATE!>a<!>
else v.<!UNSAFE_CALL!>a<!>
if (p && v!! == D("?", false)) v.a
else v.<!INAPPLICABLE_CANDIDATE!>a<!>
if (p || v!!.b) v.<!INAPPLICABLE_CANDIDATE!>a<!>
else v.<!UNSAFE_CALL!>a<!>
if (p || v!!.b) v.<!UNSAFE_CALL!>a<!>
else v.a
if (p || v!! == D("?", false)) v.<!INAPPLICABLE_CANDIDATE!>a<!>
if (p || v!! == D("?", false)) v.<!UNSAFE_CALL!>a<!>
else v.a
return ""
}

2
compiler/testData/diagnostics/tests/smartCasts/extensionSafeCall.fir.kt vendored
View File

@@ -9,5 +9,5 @@ fun <T> T?.let(f: (T) -> Unit) {
fun test(your: Your?) {
(your?.foo() as? Any)?.let {}
// strange smart cast to 'Your' at this point
your.<!INAPPLICABLE_CANDIDATE!>hashCode<!>()
your.<!UNSAFE_CALL!>hashCode<!>()
}

2
compiler/testData/diagnostics/tests/smartCasts/fieldExclExcl.fir.kt vendored
View File

@@ -7,6 +7,6 @@ fun foo() {
var y: My? = My(42)
if (y!!.x != null) {
y = My(null)
y!!.x.<!INAPPLICABLE_CANDIDATE!>hashCode<!>()
y!!.x.<!UNSAFE_CALL!>hashCode<!>()
}
}

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