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

Introduce FirInitializerTypeMismatchChecker

Browse Source
This commit is contained in:
vldf
2021-03-01 19:29:59 +03:00
committed by Mikhail Glukhikh
parent 7ed35e5c2b
commit 24f1f1221e
114 changed files with 647 additions and 285 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/analysis-tests/testData/resolve/treeSet.kt
Vendored
+1 -1
View File
@@ -1,3 +1,3 @@
import java.util.*
val x: SortedSet<Int> = TreeSet()
val x: SortedSet<Int> = <!INITIALIZER_TYPE_MISMATCH!>TreeSet()<!>
compiler/fir/analysis-tests/testData/resolveWithStdlib/diagnostics/initializerTypeMismatchChecker/InitializerTypeMismatch
Vendored
+31
View File
@@ -0,0 +1,31 @@
// FULL_JDK
import java.util.*
open class A
open class B : A()
class C : B()
fun foo() {
// InitializerTypeMismatchChecker doesn't report here due this is work for another checker
val (a: Int, b: Int) = bar()
}
fun bar(): Pair<Int?, Int?> = null to null
class Classes {
val p: Int = 1 // ok
<!INITIALIZER_TYPE_MISMATCH{LT}!>val <!INITIALIZER_TYPE_MISMATCH{PSI}!>incorrect<!>: C = B()<!>
val correct: A = C()
}
class Expressions {
val n: Number = 1 // ok
<!INITIALIZER_TYPE_MISMATCH{LT}!>val <!INITIALIZER_TYPE_MISMATCH{PSI}!>s<!>: Number = "" // not ok<!>
<!INITIALIZER_TYPE_MISMATCH{LT}!>val <!INITIALIZER_TYPE_MISMATCH{PSI}!>s2<!>: Number = "" + "expression" // not ok<!>
}
class Generics {
val n: SortedSet<Int> = TreeSet() // ok
val b: SortedSet<Int> = TreeSet<Int>() // ok
}
compiler/fir/analysis-tests/testData/resolveWithStdlib/diagnostics/initializerTypeMismatchChecker/InitializerTypeMismatch.fir.txt
Vendored
+69
View File
@@ -0,0 +1,69 @@
FILE: InitializerTypeMismatch.kt
public open class A : R|kotlin/Any| {
public constructor(): R|A| {
super<R|kotlin/Any|>()
}
}
public open class B : R|A| {
public constructor(): R|B| {
super<R|A|>()
}
}
public final class C : R|B| {
public constructor(): R|C| {
super<R|B|>()
}
}
public final fun foo(): R|kotlin/Unit| {
lval <destruct>: R|kotlin/Pair<kotlin/Int?, kotlin/Int?>| = R|/bar|()
lval a: R|kotlin/Int| = R|<local>/<destruct>|.R|SubstitutionOverride<kotlin/Pair.component1: R|kotlin/Int?|>|()
lval b: R|kotlin/Int| = R|<local>/<destruct>|.R|SubstitutionOverride<kotlin/Pair.component2: R|kotlin/Int?|>|()
}
public final fun bar(): R|kotlin/Pair<kotlin/Int?, kotlin/Int?>| {
^bar Null(null).R|kotlin/to|<R|kotlin/Nothing?|, R|kotlin/Nothing?|>(Null(null))
}
public final class Classes : R|kotlin/Any| {
public constructor(): R|Classes| {
super<R|kotlin/Any|>()
}
public final val p: R|kotlin/Int| = Int(1)
public get(): R|kotlin/Int|
public final val incorrect: R|C| = R|/B.B|()
public get(): R|C|
public final val correct: R|A| = R|/C.C|()
public get(): R|A|
}
public final class Expressions : R|kotlin/Any| {
public constructor(): R|Expressions| {
super<R|kotlin/Any|>()
}
public final val n: R|kotlin/Number| = Int(1)
public get(): R|kotlin/Number|
public final val s: R|kotlin/Number| = String()
public get(): R|kotlin/Number|
public final val s2: R|kotlin/Number| = String().R|kotlin/String.plus|(String(expression))
public get(): R|kotlin/Number|
}
public final class Generics : R|kotlin/Any| {
public constructor(): R|Generics| {
super<R|kotlin/Any|>()
}
public final val n: R|java/util/SortedSet<kotlin/Int>| = R|java/util/TreeSet.TreeSet|<R|ft<kotlin/Int, kotlin/Int?>|>()
public get(): R|java/util/SortedSet<kotlin/Int>|
public final val b: R|java/util/SortedSet<kotlin/Int>| = R|java/util/TreeSet.TreeSet|<R|ft<kotlin/Int, kotlin/Int?>|>()
public get(): R|java/util/SortedSet<kotlin/Int>|
}
compiler/fir/analysis-tests/testData/resolveWithStdlib/diagnostics/initializerTypeMismatchChecker/functionType.fir.txt
Vendored
+43
View File
@@ -0,0 +1,43 @@
FILE: TestCase1.kt
public final class Case : R|kotlin/Any| {
public constructor(): R|testsCase1/Case| {
super<R|kotlin/Any|>()
}
public final fun case(v: R|testsCase1/V|): R|kotlin/Unit| {
lval va: R|() -> kotlin/String| = Q|testsCase1/V|::R|testsCase1/a|
lval vb: R|() -> kotlin/String| = Q|testsCase1/V|::R|testsCase1/V.Companion.b|
lval va1: R|() -> kotlin/String| = R|<local>/v|::R|testsCase1/a|
lval vb1: R|() -> kotlin/String| = Q|testsCase1/V|::R|testsCase1/V.Companion.b|
}
public final val R|testsCase1/V.Companion|.b: R|kotlin/String|
public get(): R|kotlin/String| {
^ String(1)
}
}
public final val R|testsCase1/V|.a: R|kotlin/String|
public get(): R|kotlin/String| {
^ String(1)
}
public final val R|testsCase1/V.Companion|.a: R|kotlin/String|
public get(): R|kotlin/String| {
^ String(1)
}
public final class V : R|kotlin/Any| {
public constructor(): R|testsCase1/V| {
super<R|kotlin/Any|>()
}
public final companion object Companion : R|kotlin/Any| {
private constructor(): R|testsCase1/V.Companion| {
super<R|kotlin/Any|>()
}
public final const val b: R|kotlin/String| = String(1)
public get(): R|kotlin/String|
}
}
compiler/fir/analysis-tests/testData/resolveWithStdlib/diagnostics/initializerTypeMismatchChecker/functionType.kt
Vendored
+39
View File
@@ -0,0 +1,39 @@
// FULL_JDK
// !DIAGNOSTICS: -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNUSED_PARAMETER -UNUSED_EXPRESSION
// SKIP_TXT
// FILE: TestCase1.kt
// TESTCASE NUMBER: 1
package testsCase1
class Case() {
fun case(v: V) {
// InitializerTypeMismatchChecker bug
val va: () -> String = <!INITIALIZER_TYPE_MISMATCH!>(V)::a<!>
val vb: () -> String = (V)::b
val va1: () -> String = v::a
val vb1: () -> String = (V)::b
}
val V.Companion.b: String // (3)
get() = "1"
}
val V.a: String
get() = "1"
val V.Companion.a: String
get() = "1"
class V {
companion object {
const val b: String = "1"
}
}
compiler/fir/analysis-tests/testData/resolveWithStdlib/functionX.kt
Vendored
+1 -1
View File
@@ -1,6 +1,6 @@
import kotlin.jvm.functions.Function0
val x: Function0<Int> = { 42 }
val x: Function0<Int> = <!INITIALIZER_TYPE_MISMATCH!>{ 42 }<!>
val y: Function1<String, String> = { it }
compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticTestGenerated.java
Generated
+26
View File
@@ -4772,6 +4772,32 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest {
}
}
@Nested
@TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/diagnostics")
@TestDataPath("$PROJECT_ROOT")
public class Diagnostics {
@Test
public void testAllFilesPresentInDiagnostics() throws Exception {
KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/diagnostics"), Pattern.compile("^([^.]+)\\.kt$"), null, true);
}
@Nested
@TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/diagnostics/initializerTypeMismatchChecker")
@TestDataPath("$PROJECT_ROOT")
public class InitializerTypeMismatchChecker {
@Test
public void testAllFilesPresentInInitializerTypeMismatchChecker() throws Exception {
KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/diagnostics/initializerTypeMismatchChecker"), Pattern.compile("^([^.]+)\\.kt$"), null, true);
}
@Test
@TestMetadata("functionType.kt")
public void testFunctionType() throws Exception {
runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/diagnostics/initializerTypeMismatchChecker/functionType.kt");
}
}
}
@Nested
@TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/inference")
@TestDataPath("$PROJECT_ROOT")
compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticsWithLightTreeTestGenerated.java
Generated
+28
View File
@@ -4841,6 +4841,34 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos
}
}
@Nested
@TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/diagnostics")
@TestDataPath("$PROJECT_ROOT")
@Execution(ExecutionMode.SAME_THREAD)
public class Diagnostics {
@Test
public void testAllFilesPresentInDiagnostics() throws Exception {
KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/diagnostics"), Pattern.compile("^([^.]+)\\.kt$"), null, true);
}
@Nested
@TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/diagnostics/initializerTypeMismatchChecker")
@TestDataPath("$PROJECT_ROOT")
@Execution(ExecutionMode.SAME_THREAD)
public class InitializerTypeMismatchChecker {
@Test
public void testAllFilesPresentInInitializerTypeMismatchChecker() throws Exception {
KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/diagnostics/initializerTypeMismatchChecker"), Pattern.compile("^([^.]+)\\.kt$"), null, true);
}
@Test
@TestMetadata("functionType.kt")
public void testFunctionType() throws Exception {
runTest("compiler/fir/analysis-tests/testData/resolveWithStdlib/diagnostics/initializerTypeMismatchChecker/functionType.kt");
}
}
}
@Nested
@TestMetadata("compiler/fir/analysis-tests/testData/resolveWithStdlib/inference")
@TestDataPath("$PROJECT_ROOT")
compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/DiagnosticData.kt
+2 -1
View File
@@ -56,9 +56,10 @@ enum class PositioningStrategy(private val strategy: String? = null) {
VALUE_ARGUMENTS,
SUPERTYPES_LIST,
RETURN_WITH_LABEL,
ASSIGNMENT_VALUE,
INT_LITERAL_OUT_OF_RANGE,
FLOAT_LITERAL_OUT_OF_RANGE,
LONG_LITERAL_SUFFIX
LONG_LITERAL_SUFFIX,
;
compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt
+4
View File
@@ -495,6 +495,10 @@ object DIAGNOSTICS_LIST : DiagnosticList() {
parameter<ConeKotlinType>("expectedType")
parameter<ConeKotlinType>("actualType")
}
val INITIALIZER_TYPE_MISMATCH by error<FirSourceElement, KtProperty>(PositioningStrategy.ASSIGNMENT_VALUE) {
parameter<ConeKotlinType>("expected")
parameter<ConeKotlinType>("actual")
}
}
val MPP_PROJECTS by object : DiagnosticGroup("Multi-platform projects") {
compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt
+1
View File
@@ -312,6 +312,7 @@ object FirErrors {
val CONST_VAL_WITH_GETTER by error0<FirSourceElement, KtProperty>()
val CONST_VAL_WITH_DELEGATE by error0<FirSourceElement, KtPropertyDelegate>()
val WRONG_SETTER_PARAMETER_TYPE by error2<FirSourceElement, KtTypeReference, ConeKotlinType, ConeKotlinType>()
val INITIALIZER_TYPE_MISMATCH by error2<FirSourceElement, KtProperty, ConeKotlinType, ConeKotlinType>(SourceElementPositioningStrategies.ASSIGNMENT_VALUE)
// Multi-platform projects
val EXPECTED_DECLARATION_WITH_BODY by error0<FirSourceElement, KtDeclaration>(SourceElementPositioningStrategies.DECLARATION_SIGNATURE)
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInitializerTypeMismatchChecker.kt
+72
View File
@@ -0,0 +1,72 @@
/*
* Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
*/
package org.jetbrains.kotlin.fir.analysis.checkers.declaration
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INITIALIZER_TYPE_MISMATCH
import org.jetbrains.kotlin.fir.declarations.FirProperty
import org.jetbrains.kotlin.fir.expressions.FirComponentCall
import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.resolve.inference.isFunctionalType
import org.jetbrains.kotlin.fir.typeContext
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.types.AbstractTypeChecker
object FirInitializerTypeMismatchChecker : FirPropertyChecker() {
override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) {
val initializer = declaration.initializer ?: return
if (declaration.isDestructuringDeclaration) return
if (initializer.isComponent) return
val propertyType = declaration.returnTypeRef.coneTypeSafe<ConeKotlinType>() ?: return
val expressionType = initializer.typeRef.coneTypeSafe<ConeKotlinType>() ?: return
val typeContext = context.session.typeContext
// hack: if property's type is (args) -> Unit, and lambda returns non-Unit value, the type of the lambda
// will be non-unit, but it's OK
if (propertyType.isFunctionalType(context.session)) {
// getting property's expected return type
val expectedType = propertyType.typeArguments.lastOrNull()
if ((expectedType as? ConeClassLikeType)?.isUnit == true) {
// dropping the return type (getting only the lambda args)
val expectedArgs = propertyType.typeArguments.dropLast(1)
val actualArgs = expressionType.typeArguments.dropLast(1)
if (compareTypesList(actualArgs, expectedArgs, typeContext)) {
return
}
}
}
if (!AbstractTypeChecker.isSubtypeOf(typeContext, expressionType, propertyType)) {
val source = declaration.source ?: return
reporter.report(INITIALIZER_TYPE_MISMATCH.on(source, propertyType, expressionType), context)
}
}
private val FirProperty.isDestructuringDeclaration
get() = name.asString() == "<destruct>"
private val FirExpression.isComponent
get() = this is FirComponentCall
private fun compareTypesList(
expressionTypes: List<ConeTypeProjection>,
propertyTypes: List<ConeTypeProjection>,
context: ConeInferenceContext
): Boolean {
if (expressionTypes.size != propertyTypes.size) return false
for (i in expressionTypes.indices) {
val expressionType = expressionTypes[i].type ?: return false
val propertyType = propertyTypes[i].type ?: return false
if (!AbstractTypeChecker.isSubtypeOf(context.session.typeContext, expressionType, propertyType)) {
return false
}
}
return true
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt
+2
View File
@@ -108,6 +108,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INAPPLICABLE_LATE
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INCOMPATIBLE_MODIFIERS
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INFERENCE_ERROR
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INITIALIZER_REQUIRED_FOR_DESTRUCTURING_DECLARATION
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INITIALIZER_TYPE_MISMATCH
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INLINE_CLASS_CANNOT_BE_RECURSIVE
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INLINE_CLASS_CANNOT_EXTEND_CLASSES
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INLINE_CLASS_CANNOT_IMPLEMENT_INTERFACE_BY_DELEGATION
@@ -687,6 +688,7 @@ class FirDefaultErrorMessages : DefaultErrorMessages.Extension {
RENDER_TYPE,
RENDER_TYPE
)
map.put(INITIALIZER_TYPE_MISMATCH, "Initializer type mismatch: expected {0}, actual {1}", RENDER_TYPE, RENDER_TYPE)
// Multi-platform projects
map.put(EXPECTED_DECLARATION_WITH_BODY, "Expected declaration must not have a body")
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/LightTreePositioningStrategies.kt
+14
View File
@@ -8,11 +8,13 @@ package org.jetbrains.kotlin.fir.analysis.diagnostics
import com.intellij.lang.LighterASTNode
import com.intellij.openapi.util.Ref
import com.intellij.openapi.util.TextRange
import com.intellij.psi.impl.source.tree.ElementType
import com.intellij.psi.tree.IElementType
import com.intellij.psi.tree.TokenSet
import com.intellij.util.diff.FlyweightCapableTreeStructure
import org.jetbrains.kotlin.KtNodeTypes
import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.analysis.checkers.getChildren
import org.jetbrains.kotlin.lexer.KtTokens
import org.jetbrains.kotlin.lexer.KtTokens.MODALITY_MODIFIERS
import org.jetbrains.kotlin.lexer.KtTokens.VISIBILITY_MODIFIERS
@@ -240,6 +242,18 @@ object LightTreePositioningStrategies {
}
}
val ASSIGNMENT_VALUE: LightTreePositioningStrategy = object : LightTreePositioningStrategy() {
override fun mark(
node: LighterASTNode,
startOffset: Int,
endOffset: Int,
tree: FlyweightCapableTreeStructure<LighterASTNode>
): List<TextRange> {
val value = tree.lastChild(node) ?: node
return markElement(value, startOffset, endOffset, tree, node)
}
}
private val LighterASTNode.isDeclaration: Boolean
get() =
when (tokenType) {
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/SourceElementPositioningStrategies.kt
+5
View File
@@ -178,6 +178,11 @@ object SourceElementPositioningStrategies {
PositioningStrategies.RETURN_WITH_LABEL
)
val ASSIGNMENT_VALUE = SourceElementPositioningStrategy(
LightTreePositioningStrategies.ASSIGNMENT_VALUE,
PositioningStrategies.ASSIGNMENT_VALUE
)
val LONG_LITERAL_SUFFIX = SourceElementPositioningStrategy(
LightTreePositioningStrategies.LONG_LITERAL_SUFFIX,
PositioningStrategies.LONG_LITERAL_SUFFIX
compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/CommonDeclarationCheckers.kt
+2 -1
View File
@@ -41,7 +41,8 @@ object CommonDeclarationCheckers : DeclarationCheckers() {
FirInapplicableLateinitChecker,
FirDestructuringDeclarationChecker,
FirConstPropertyChecker,
FirPropertyAccessorChecker
FirPropertyAccessorChecker,
FirInitializerTypeMismatchChecker
)
override val classCheckers: Set<FirClassChecker> = setOf(
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt
+20
View File
@@ -780,6 +780,26 @@ object PositioningStrategies {
val REFERENCE_BY_QUALIFIED: PositioningStrategy<PsiElement> = FindReferencePositioningStrategy(false)
val REFERENCED_NAME_BY_QUALIFIED: PositioningStrategy<PsiElement> = FindReferencePositioningStrategy(true)
val ASSIGNMENT_VALUE: PositioningStrategy<KtProperty> = object : PositioningStrategy<PsiElement>() {
override fun mark(element: PsiElement): List<TextRange> {
return if (element is KtProperty) {
mark(element.initializer ?: element)
} else {
super.mark(element)
}
}
}
val RETURN_EXPRESSION: PositioningStrategy<KtReturnExpression> = object : PositioningStrategy<PsiElement>() {
override fun mark(element: PsiElement): List<TextRange> {
return if (element is KtReturnExpression) {
markElement(element.returnedExpression ?: element)
} else {
markElement(element)
}
}
}
/**
* @param locateReferencedName whether to remove any nested parentheses while locating the reference element. This is useful for
* diagnostics on super and unresolved references. For example, with the following, only the part inside the parentheses should be
compiler/testData/diagnostics/tests/Basic.fir.kt
Vendored
+1 -1
View File
@@ -10,7 +10,7 @@ fun test() : Int {
}
class A() {
val x : Int = foo1(<!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>xx<!>)
val x : Int = <!INITIALIZER_TYPE_MISMATCH!>foo1(<!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>xx<!>)<!>
}
fun foo1() {}
compiler/testData/diagnostics/tests/FunctionReturnTypes.fir.kt
Vendored
+10 -10
View File
@@ -171,31 +171,31 @@ class B() {
}
fun testFunctionLiterals() {
val endsWithVarDeclaration : () -> Boolean = {
val endsWithVarDeclaration : () -> Boolean = <!INITIALIZER_TYPE_MISMATCH!>{
val x = 2
}
}<!>
val endsWithAssignment: () -> Int = {
val endsWithAssignment: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>{
var x = 1
x = 333
}
}<!>
val endsWithReAssignment: () -> Int = {
val endsWithReAssignment: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>{
var x = 1
x += 333
}
}<!>
val endsWithFunDeclaration : () -> String = {
val endsWithFunDeclaration : () -> String = <!INITIALIZER_TYPE_MISMATCH!>{
var x = 1
x = 333
fun meow() : Unit {}
}
}<!>
val endsWithObjectDeclaration : () -> Int = {
val endsWithObjectDeclaration : () -> Int = <!INITIALIZER_TYPE_MISMATCH!>{
var x = 1
x = 333
<!LOCAL_OBJECT_NOT_ALLOWED!>object A<!> {}
}
}<!>
val expectedUnitReturnType1: () -> Unit = {
val x = 1
compiler/testData/diagnostics/tests/PackageQualified.fir.kt
Vendored
+1 -1
View File
@@ -20,7 +20,7 @@ abstract class Foo<T>() {
package foobar.a
import java.util.*
val b : List<Int>? = a
val b : List<Int>? = <!INITIALIZER_TYPE_MISMATCH!>a<!>
val b1 : <!UNRESOLVED_REFERENCE!>util.List<Int>?<!> = a
// FILE: d.kt
compiler/testData/diagnostics/tests/QualifiedExpressions.fir.kt
Vendored
+1 -1
View File
@@ -2,7 +2,7 @@
package qualified_expressions
fun test(s: IntRange?) {
val a: Int = s?.start
val a: Int = <!INITIALIZER_TYPE_MISMATCH!>s?.start<!>
val b: Int? = s?.start
val c: Int = s?.start ?: -11
val d: Int = s?.start ?: "empty"
compiler/testData/diagnostics/tests/SafeCallNonNullReceiverReturnNull.fir.kt
Vendored
+1 -1
View File
@@ -3,5 +3,5 @@ fun Int.gg() = null
fun ff() {
val a: Int = 1
val b: Int = a<!UNNECESSARY_SAFE_CALL!>?.<!>gg()
val b: Int = <!INITIALIZER_TYPE_MISMATCH!>a<!UNNECESSARY_SAFE_CALL!>?.<!>gg()<!>
}
compiler/testData/diagnostics/tests/Variance.fir.kt
Vendored
+2 -2
View File
@@ -8,13 +8,13 @@ abstract class Producer<out T> {}
abstract class Usual<T> {}
fun foo(c: Consumer<Int>, p: Producer<Int>, u: Usual<Int>) {
val c1: Consumer<Any> = c
val c1: Consumer<Any> = <!INITIALIZER_TYPE_MISMATCH!>c<!>
val c2: Consumer<Int> = c1
val p1: Producer<Any> = p
val p2: Producer<Int> = p1
val u1: Usual<Any> = u
val u1: Usual<Any> = <!INITIALIZER_TYPE_MISMATCH!>u<!>
val u2: Usual<Int> = u1
}
compiler/testData/diagnostics/tests/annotations/annotationOnParameterInFunctionType.fir.kt
Vendored
+1 -1
View File
@@ -24,6 +24,6 @@ class A : (@Ann Int)->Unit {
@Target(AnnotationTarget.TYPE)
annotation class TypeAnn
val onType: (@TypeAnn A).(@Ann a: @TypeAnn A, @TypeAnn A)->@TypeAnn A? = { null }
val onType: (@TypeAnn A).(@Ann a: @TypeAnn A, @TypeAnn A)->@TypeAnn A? = <!INITIALIZER_TYPE_MISMATCH!>{ null }<!>
fun (@TypeAnn A).extFun(@Ann a: @TypeAnn A): @TypeAnn A? = null
compiler/testData/diagnostics/tests/callableReference/generic/argumentAndReturnExpectedType.fir.kt
Vendored
+1 -1
View File
@@ -18,7 +18,7 @@ fun test1() {
bar("", 1, ::fooTakeString).checkType { _<Pair<String, Int>>() }
bar("", "", ::fooReturnInt).checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Pair<String, Any>>() }
val x: String = bar("", "", ::fooReturnInt)
val x: String = <!INITIALIZER_TYPE_MISMATCH!>bar("", "", ::fooReturnInt)<!>
baz(Int::toString, ::foo).checkType { _<Pair<Int, String>>() }
}
compiler/testData/diagnostics/tests/callableReference/generic/genericFunctionsWithNullableTypes.fir.kt
Vendored
+2 -2
View File
@@ -30,8 +30,8 @@ fun <T> test(x: T) {
baz(null, null, ::foo)
val s3: Pair<Int, String?> = bar(null, null, ::foo)
val s4: Pair<Int?, String> = bar(null, null, ::foo)
val s4: Pair<Int?, String> = <!INITIALIZER_TYPE_MISMATCH!>bar(null, null, ::foo)<!>
val s5: Pair<Int, String> = bar(1, "", ::foo)
val s5: Pair<Int, String> = <!INITIALIZER_TYPE_MISMATCH!>bar(1, "", ::foo)<!>
val (a1: Int, b1: String) = <!COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH!>bar(1, "", ::foo)<!>
}
compiler/testData/diagnostics/tests/callableReference/generic/resolutionGenericCallableWithNullableTypes.fir.kt
Vendored
+3 -3
View File
@@ -17,7 +17,7 @@ fun test1() {
baz<String>(::foo).checkType { _<String?>() }
baz<Boolean>(::foo).checkType { _<Boolean?>() }
val b1: Int = baz(::<!UNRESOLVED_REFERENCE!>foo<!>)
val b2: String = baz(::<!UNRESOLVED_REFERENCE!>foo<!>)
val b3: Boolean = baz(::<!UNRESOLVED_REFERENCE!>foo<!>)
val b1: Int = <!INITIALIZER_TYPE_MISMATCH!>baz(::<!UNRESOLVED_REFERENCE!>foo<!>)<!>
val b2: String = <!INITIALIZER_TYPE_MISMATCH!>baz(::<!UNRESOLVED_REFERENCE!>foo<!>)<!>
val b3: Boolean = <!INITIALIZER_TYPE_MISMATCH!>baz(::<!UNRESOLVED_REFERENCE!>foo<!>)<!>
}
compiler/testData/diagnostics/tests/classLiteral/classLiteralType.fir.kt
Vendored
+2 -2
View File
@@ -8,8 +8,8 @@ val arrayOfString: Array<String> = null!!
val a1 : KClass<*> = A::class
val a2 : KClass<A> = A::class
val a3 : KClass<B> = A::class
val a4 : B = A::class
val a3 : KClass<B> = <!INITIALIZER_TYPE_MISMATCH!>A::class<!>
val a4 : B = <!INITIALIZER_TYPE_MISMATCH!>A::class<!>
val a5 : KClass<out List<String>> = listOfString::class
val a6 : KClass<out Array<String>> = arrayOfString::class
compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.fir.kt
Vendored
+2 -2
View File
@@ -27,7 +27,7 @@ fun foo() {
z = 34
}
}
val f: ()-> Int = r
val f: ()-> Int = <!INITIALIZER_TYPE_MISMATCH!>r<!>
val g: ()-> Any = r
}
@@ -80,7 +80,7 @@ fun testCoercionToUnit() {
45
}
}
val f : () -> String = checkType
val f : () -> String = <!INITIALIZER_TYPE_MISMATCH!>checkType<!>
}
fun doSmth(i: Int) {}
compiler/testData/diagnostics/tests/controlStructures/specialConstructsAndPlatformTypes.fir.kt
Vendored
+5 -5
View File
@@ -12,7 +12,7 @@ public class J {
val testImplicitExclExcl1: String = J.s
val testImplicitExclExcl2: String? = J.s
val testImplicitExclExcl3: String = J.m[""]
val testImplicitExclExcl3: String = <!INITIALIZER_TYPE_MISMATCH!>J.m[""]<!>
val testImplicitExclExcl4: String? = J.m[""]
val testExclExcl1: String = J.s!!
@@ -21,20 +21,20 @@ val testExclExcl2: String? = J.s!!
val testExclExcl3: String = J.m[""]!!
val testExclExcl4: String? = J.m[""]!!
val testSafeCall1: String = J.s?.let { it }
val testSafeCall1: String = <!INITIALIZER_TYPE_MISMATCH!>J.s?.let { it }<!>
val testSafeCall2: String? = J.s?.let { it }
val testSafeCall3: String = J.m[""]?.let { it }
val testSafeCall3: String = <!INITIALIZER_TYPE_MISMATCH!>J.m[""]?.let { it }<!>
val testSafeCall4: String? = J.m[""]?.let { it.toString() }
val testIf1: String = if (true) J.s else J.s
val testIf2: String? = if (true) J.s else J.s
val testIf3: String = if (true) J.m[""] else J.m[""]
val testIf3: String = <!INITIALIZER_TYPE_MISMATCH!>if (true) J.m[""] else J.m[""]<!>
val testIf4: String? = if (true) J.m[""] else J.m[""]
val testWhen1: String = when { else -> J.s }
val testWhen2: String? = when { else -> J.s }
val testWhen3: String = when { else -> J.m[""] }
val testWhen3: String = <!INITIALIZER_TYPE_MISMATCH!>when { else -> J.m[""] }<!>
val testWhen4: String? = when { else -> J.m[""] }
compiler/testData/diagnostics/tests/cyclicHierarchy/kt303.fir.kt
Vendored
+1 -1
View File
@@ -9,4 +9,4 @@ open class Bar() : <!OTHER_ERROR!>Foo<!>() {
}
val x : Int = Foo()
val x : Int = <!INITIALIZER_TYPE_MISMATCH!>Foo()<!>
compiler/testData/diagnostics/tests/declarationChecks/ScalaLikeNamedFun.fir.kt
Vendored
+8 -8
View File
@@ -3,16 +3,16 @@
fun test1(): Int = { <!RETURN_NOT_ALLOWED!>return<!> 1 }
fun test2(): Int = { 1 }
val test3: () -> Int = fun (): Int = { <!RETURN_NOT_ALLOWED!>return<!> 1 }
val test4: () -> Int = fun (): Int = { 1 }
val test3: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (): Int = { <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
val test4: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (): Int = { 1 }<!>
fun test5(): Int { return { 1 } }
fun test6(): Int = fun (): Int = 1
fun outer() {
fun test1(): Int = { <!RETURN_NOT_ALLOWED!>return<!> 1 }
fun test2(): Int = { 1 }
val test3: () -> Int = fun (): Int = { <!RETURN_NOT_ALLOWED!>return<!> 1 }
val test4: () -> Int = fun (): Int = { 1 }
val test3: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (): Int = { <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
val test4: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (): Int = { 1 }<!>
fun test5(): Int { return { 1 } }
fun test6(): Int = fun (): Int = 1
}
@@ -20,16 +20,16 @@ fun outer() {
class Outer {
fun test1(): Int = { <!RETURN_NOT_ALLOWED!>return<!> 1 }
fun test2(): Int = { 1 }
val test3: () -> Int = fun (): Int = { <!RETURN_NOT_ALLOWED!>return<!> 1 }
val test4: () -> Int = fun (): Int = { 1 }
val test3: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (): Int = { <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
val test4: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (): Int = { 1 }<!>
fun test5(): Int { return { 1 } }
fun test6(): Int = fun (): Int = 1
class Nested {
fun test1(): Int = { <!RETURN_NOT_ALLOWED!>return<!> 1 }
fun test2(): Int = { 1 }
val test3: () -> Int = fun (): Int = { <!RETURN_NOT_ALLOWED!>return<!> 1 }
val test4: () -> Int = fun (): Int = { 1 }
val test3: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (): Int = { <!RETURN_NOT_ALLOWED!>return<!> 1 }<!>
val test4: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (): Int = { 1 }<!>
fun test5(): Int { return { 1 } }
fun test6(): Int = fun (): Int = 1
}
compiler/testData/diagnostics/tests/deparenthesize/checkDeparenthesizedType.fir.kt
Vendored
+3 -3
View File
@@ -13,10 +13,10 @@ fun test(i: Int?) {
foo((l3@ i))
}
val a: Int = l4@ ""
val b: Int = ("")
val a: Int = <!INITIALIZER_TYPE_MISMATCH!>l4@ ""<!>
val b: Int = <!INITIALIZER_TYPE_MISMATCH!>("")<!>
val c: Int = checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
val d: Int = checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH!>""<!>)
val d: Int = <!INITIALIZER_TYPE_MISMATCH!>checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH!>""<!>)<!>
foo(l4@ <!ARGUMENT_TYPE_MISMATCH!>""<!>)
compiler/testData/diagnostics/tests/evaluate/binaryMinusIndependentExpType.fir.kt
Vendored
+15 -15
View File
@@ -1,24 +1,24 @@
val p1: Int = 1 - 1
val p2: Long = 1 - 1
val p3: Byte = 1 - 1
val p4: Short = 1 - 1
val p2: Long = <!INITIALIZER_TYPE_MISMATCH!>1 - 1<!>
val p3: Byte = <!INITIALIZER_TYPE_MISMATCH!>1 - 1<!>
val p4: Short = <!INITIALIZER_TYPE_MISMATCH!>1 - 1<!>
val l1: Long = 1 - 1.toLong()
val l2: Byte = 1 - 1.toLong()
val l3: Int = 1 - 1.toLong()
val l4: Short = 1 - 1.toLong()
val l2: Byte = <!INITIALIZER_TYPE_MISMATCH!>1 - 1.toLong()<!>
val l3: Int = <!INITIALIZER_TYPE_MISMATCH!>1 - 1.toLong()<!>
val l4: Short = <!INITIALIZER_TYPE_MISMATCH!>1 - 1.toLong()<!>
val b1: Byte = 1 - 1.toByte()
val b1: Byte = <!INITIALIZER_TYPE_MISMATCH!>1 - 1.toByte()<!>
val b2: Int = 1 - 1.toByte()
val b3: Long = 1 - 1.toByte()
val b4: Short = 1 - 1.toByte()
val b3: Long = <!INITIALIZER_TYPE_MISMATCH!>1 - 1.toByte()<!>
val b4: Short = <!INITIALIZER_TYPE_MISMATCH!>1 - 1.toByte()<!>
val i1: Byte = 1 - 1.toInt()
val i1: Byte = <!INITIALIZER_TYPE_MISMATCH!>1 - 1.toInt()<!>
val i2: Int = 1 - 1.toInt()
val i3: Long = 1 - 1.toInt()
val i4: Short = 1 - 1.toInt()
val i3: Long = <!INITIALIZER_TYPE_MISMATCH!>1 - 1.toInt()<!>
val i4: Short = <!INITIALIZER_TYPE_MISMATCH!>1 - 1.toInt()<!>
val s1: Byte = 1 - 1.toShort()
val s1: Byte = <!INITIALIZER_TYPE_MISMATCH!>1 - 1.toShort()<!>
val s2: Int = 1 - 1.toShort()
val s3: Long = 1 - 1.toShort()
val s4: Short = 1 - 1.toShort()
val s3: Long = <!INITIALIZER_TYPE_MISMATCH!>1 - 1.toShort()<!>
val s4: Short = <!INITIALIZER_TYPE_MISMATCH!>1 - 1.toShort()<!>
compiler/testData/diagnostics/tests/evaluate/integer.fir.kt
Vendored
+5 -5
View File
@@ -1,8 +1,8 @@
val a1: Int = 1L
val a2: Int = 0x1L
val a3: Int = 0X1L
val a4: Int = 0b1L
val a5: Int = 0B1L
val a1: Int = <!INITIALIZER_TYPE_MISMATCH!>1L<!>
val a2: Int = <!INITIALIZER_TYPE_MISMATCH!>0x1L<!>
val a3: Int = <!INITIALIZER_TYPE_MISMATCH!>0X1L<!>
val a4: Int = <!INITIALIZER_TYPE_MISMATCH!>0b1L<!>
val a5: Int = <!INITIALIZER_TYPE_MISMATCH!>0B1L<!>
val a6: Long = 1L
val a7: Long = 0x1L
val a8: Long = 0X1L
compiler/testData/diagnostics/tests/evaluate/parentesized.fir.kt
Vendored
+5 -5
View File
@@ -1,10 +1,10 @@
val p1: Byte = (1 + 2) * 2
val p2: Short = (1 + 2) * 2
val p1: Byte = <!INITIALIZER_TYPE_MISMATCH!>(1 + 2) * 2<!>
val p2: Short = <!INITIALIZER_TYPE_MISMATCH!>(1 + 2) * 2<!>
val p3: Int = (1 + 2) * 2
val p4: Long = (1 + 2) * 2
val p4: Long = <!INITIALIZER_TYPE_MISMATCH!>(1 + 2) * 2<!>
val b1: Byte = (1.toByte() + 2) * 2
val b2: Short = (1.toShort() + 2) * 2
val b1: Byte = <!INITIALIZER_TYPE_MISMATCH!>(1.toByte() + 2) * 2<!>
val b2: Short = <!INITIALIZER_TYPE_MISMATCH!>(1.toShort() + 2) * 2<!>
val b3: Int = (1.toInt() + 2) * 2
val b4: Long = (1.toLong() + 2) * 2
compiler/testData/diagnostics/tests/evaluate/unaryMinusIndependentExpType.fir.kt
Vendored
+15 -15
View File
@@ -3,27 +3,27 @@ val p2: Long = -1
val p3: Byte = -1
val p4: Short = -1
val lp1: Int = -1111111111111111111
val lp1: Int = <!INITIALIZER_TYPE_MISMATCH!>-1111111111111111111<!>
val lp2: Long = -1111111111111111111
val lp3: Byte = -1111111111111111111
val lp4: Short = -1111111111111111111
val lp3: Byte = <!INITIALIZER_TYPE_MISMATCH!>-1111111111111111111<!>
val lp4: Short = <!INITIALIZER_TYPE_MISMATCH!>-1111111111111111111<!>
val l1: Long = -1.toLong()
val l2: Byte = -1.toLong()
val l3: Int = -1.toLong()
val l4: Short = -1.toLong()
val l2: Byte = <!INITIALIZER_TYPE_MISMATCH!>-1.toLong()<!>
val l3: Int = <!INITIALIZER_TYPE_MISMATCH!>-1.toLong()<!>
val l4: Short = <!INITIALIZER_TYPE_MISMATCH!>-1.toLong()<!>
val b1: Byte = -1.toByte()
val b1: Byte = <!INITIALIZER_TYPE_MISMATCH!>-1.toByte()<!>
val b2: Int = -1.toByte()
val b3: Long = -1.toByte()
val b4: Short = -1.toByte()
val b3: Long = <!INITIALIZER_TYPE_MISMATCH!>-1.toByte()<!>
val b4: Short = <!INITIALIZER_TYPE_MISMATCH!>-1.toByte()<!>
val i1: Byte = -1.toInt()
val i1: Byte = <!INITIALIZER_TYPE_MISMATCH!>-1.toInt()<!>
val i2: Int = -1.toInt()
val i3: Long = -1.toInt()
val i4: Short = -1.toInt()
val i3: Long = <!INITIALIZER_TYPE_MISMATCH!>-1.toInt()<!>
val i4: Short = <!INITIALIZER_TYPE_MISMATCH!>-1.toInt()<!>
val s1: Byte = -1.toShort()
val s1: Byte = <!INITIALIZER_TYPE_MISMATCH!>-1.toShort()<!>
val s2: Int = -1.toShort()
val s3: Long = -1.toShort()
val s4: Short = -1.toShort()
val s3: Long = <!INITIALIZER_TYPE_MISMATCH!>-1.toShort()<!>
val s4: Short = <!INITIALIZER_TYPE_MISMATCH!>-1.toShort()<!>
compiler/testData/diagnostics/tests/functionAsExpression/FunctionType.fir.kt
Vendored
+3 -3
View File
@@ -9,7 +9,7 @@ fun testReturnType(foo: String) {
val bas: () -> String = fun () = foo
val bag: () -> Int = fun () = foo
val bag: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun () = foo<!>
}
fun testParamType() {
@@ -18,7 +18,7 @@ fun testParamType() {
bar.checkType { _<(String) -> Unit>() }
val bas: (String) -> Unit = fun (param: String) {}
val bag: (Int) -> Unit = fun (param: String) {}
val bag: (Int) -> Unit = <!INITIALIZER_TYPE_MISMATCH!>fun (param: String) {}<!>
}
fun testReceiverType() {
@@ -28,5 +28,5 @@ fun testReceiverType() {
val bas: String.() -> Unit = fun String.() {}
val bag: Int.() -> Unit = fun String.() {}
val bag: Int.() -> Unit = <!INITIALIZER_TYPE_MISMATCH!>fun String.() {}<!>
}
compiler/testData/diagnostics/tests/functionAsExpression/InferenceParametersTypes.fir.kt
Vendored
+1 -1
View File
@@ -17,4 +17,4 @@ fun test2(a: () -> List<Int>) {
val a: (Int) -> Unit = fun(x) { checkSubtype<Int>(x) }
val b: (Int) -> Unit = fun(x: String) {}
val b: (Int) -> Unit = <!INITIALIZER_TYPE_MISMATCH!>fun(x: String) {}<!>
compiler/testData/diagnostics/tests/functionAsExpression/MissingParameterTypes.fir.kt
Vendored
+4 -4
View File
@@ -6,13 +6,13 @@ val a = fun (x) = x
val b: (Int) -> Int = fun (x) = x + 3
val c: (Int, String) -> Int = fun (x) = 3
val c: (Int, String) -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (x) = 3<!>
val d: (Int, String) -> Int = fun (x) = 3
val d: (Int, String) -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (x) = 3<!>
val e: (Int, String) -> Int = fun (x: String) = 3
val e: (Int, String) -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (x: String) = 3<!>
val f: (Int) -> Int = fun (x: String) = 3
val f: (Int) -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (x: String) = 3<!>
fun test1(a: (Int) -> Unit) {
test1(fun (x) { checkSubtype<Int>(x)})
compiler/testData/diagnostics/tests/functionLiterals/assignmentOperationInLambdaWithExpectedType.fir.kt
Vendored
+3 -3
View File
@@ -4,13 +4,13 @@ fun test(bal: Array<Int>) {
val a: () -> Unit = { bar += 4 }
val b: () -> Int = { bar = 4 }
val b: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>{ bar = 4 }<!>
val c: () -> <!UNRESOLVED_REFERENCE!>UNRESOLVED<!> = { bal[2] = 3 }
val d: () -> Int = { bar += 4 }
val d: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>{ bar += 4 }<!>
val e: Unit = run { bar += 4 }
val f: Int = run { bar += 4 }
val f: Int = <!INITIALIZER_TYPE_MISMATCH!>run { bar += 4 }<!>
}
compiler/testData/diagnostics/tests/functionLiterals/missedTypeMismatch.fir.kt
Vendored
+12 -12
View File
@@ -7,33 +7,33 @@ fun <T>id(x: T) = x
// Before the fix, there wasn't any type mismatch error in NI due to result type not being a subtype of expected type
fun main() {
val x: () -> Int = { "" }
val x: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>{ "" }<!>
val a0: () -> Int = fun(): String = "1"
val a1: () -> Int = (fun() = "1")
val a0: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun(): String = "1"<!>
val a1: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>(fun() = "1")<!>
val a2: () -> Unit = (fun() = "1")
val a3: Unit = (fun() = "1")
val a3: Unit = <!INITIALIZER_TYPE_MISMATCH!>(fun() = "1")<!>
val a4 = (fun() = "1")
val a5 = (fun(): String = "1")
val a6: () -> Int = (fun() = 1)
val a7: () -> Int = (fun(): String = "1") as () -> Int
val a8: () -> Int = fun(): String = "1"
val a8: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun(): String = "1"<!>
val a9: () -> () -> () -> Int = fun(): () -> () -> String = fun(): () -> String = fun(): String = "1"
foo(fun(): String = <!ARGUMENT_TYPE_MISMATCH!>"1"<!>)
foo(((fun(): String = <!ARGUMENT_TYPE_MISMATCH!>"1"<!>)))
val a10: Int.(String) -> Int = fun (x: String) = 10
val a10: Int.(String) -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (x: String) = 10<!>
val a11: () -> () -> () -> Int = fun() = fun() = fun(): String = "1"
val a12: Int = fun(): String = "1"
val a13: Int = fun() = fun(): String = "1"
val a14: Int = fun() = fun() = "1"
val a15: Int = fun() = fun() = {}
val a16: Int = fun() = fun() {}
val a12: Int = <!INITIALIZER_TYPE_MISMATCH!>fun(): String = "1"<!>
val a13: Int = <!INITIALIZER_TYPE_MISMATCH!>fun() = fun(): String = "1"<!>
val a14: Int = <!INITIALIZER_TYPE_MISMATCH!>fun() = fun() = "1"<!>
val a15: Int = <!INITIALIZER_TYPE_MISMATCH!>fun() = fun() = {}<!>
val a16: Int = <!INITIALIZER_TYPE_MISMATCH!>fun() = fun() {}<!>
val a17: () -> Unit = fun() {}
val a18: () -> Int = fun() {}
val a18: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun() {}<!>
val a19: () -> () -> Int = fun() = fun() {}
val a20: () -> () -> () -> Unit = fun() = fun() = {}
val a21: () -> () -> () -> Int = fun() = fun() = {}
compiler/testData/diagnostics/tests/functionLiterals/return/IfWithoutElseWithExplicitType.fir.kt
Vendored
+4 -4
View File
@@ -1,8 +1,8 @@
val flag = true
val a: () -> Int = l@ {
val a: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>l@ {
if (flag) return@l 4
}
}<!>
val b: () -> Unit = l@ {
if (flag) return@l 4
@@ -17,6 +17,6 @@ val d: () -> Int = l@ {
5
}
val e: () -> Int = l@ {
val e: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>l@ {
if (flag) 4
}
}<!>
compiler/testData/diagnostics/tests/generics/nullability/nullToGeneric.fir.kt
Vendored
+2 -2
View File
@@ -3,7 +3,7 @@
fun <E> bar(x: E) {}
fun <T> foo(): T {
val x1: T = null
val x1: T = <!INITIALIZER_TYPE_MISMATCH!>null<!>
val x2: T? = null
bar<T>(<!ARGUMENT_TYPE_MISMATCH!>null<!>)
@@ -20,7 +20,7 @@ class A<F> {
fun xyz(x: F) {}
fun foo(): F {
val x1: F = null
val x1: F = <!INITIALIZER_TYPE_MISMATCH!>null<!>
val x2: F? = null
xyz(<!ARGUMENT_TYPE_MISMATCH!>null<!>)
compiler/testData/diagnostics/tests/generics/projectionsScope/kt7296.fir.kt
Vendored
+1 -1
View File
@@ -9,7 +9,7 @@ fun main() {
val a : ArrayList<ArrayList<String>> = ArrayList()
val b : ListOfLists<String> = ListOfLists(a)
val c : ListOfLists<*> = b
val d : ArrayList<ArrayList<*>> = c.x
val d : ArrayList<ArrayList<*>> = <!INITIALIZER_TYPE_MISMATCH!>c.x<!>
c.x checkType { <!INAPPLICABLE_CANDIDATE!>_<!><ArrayList<out ArrayList<*>>>() }
}
compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchInLambda.fir.kt
Vendored
+1 -1
View File
@@ -13,7 +13,7 @@ class A<E> {
fun test(a: A<out CharSequence>, z: Out<CharSequence>) {
a.foo {
val x: String = 1 // Should be no TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS
val x: String = <!INITIALIZER_TYPE_MISMATCH!>1<!> // Should be no TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS
""
}
a.bar { Out<CharSequence>() }
compiler/testData/diagnostics/tests/generics/suppressVarianceConflict.fir.kt
Vendored
+2 -2
View File
@@ -11,7 +11,7 @@ fun foo(x: A<String, Any?>, cs: CharSequence, ls: List<CharSequence>) {
val y: A<CharSequence, String> = x
y.foo(<!ARGUMENT_TYPE_MISMATCH!>cs<!>)
val s: String = y.foo(<!ARGUMENT_TYPE_MISMATCH!>cs<!>, <!ARGUMENT_TYPE_MISMATCH!>ls<!>)
val s: String = <!INITIALIZER_TYPE_MISMATCH!>y.foo(<!ARGUMENT_TYPE_MISMATCH!>cs<!>, <!ARGUMENT_TYPE_MISMATCH!>ls<!>)<!>
val ls2: List<String> = y.bar()
val ls2: List<String> = <!INITIALIZER_TYPE_MISMATCH!>y.bar()<!>
}
compiler/testData/diagnostics/tests/imports/InaccessiblePrivateClass.fir.kt
Vendored
+1 -1
View File
@@ -14,5 +14,5 @@ package p1
import p2.*
val <!EXPOSED_PROPERTY_TYPE!>x<!>: X = X()
val <!EXPOSED_PROPERTY_TYPE!>x<!>: X = <!INITIALIZER_TYPE_MISMATCH!>X()<!>
val <!EXPOSED_PROPERTY_TYPE!>y<!>: Y = <!HIDDEN!>Y<!>()
compiler/testData/diagnostics/tests/inference/capturedTypes/captureForNullableTypes.fir.kt
Vendored
+2 -2
View File
@@ -5,7 +5,7 @@
fun <T: Any> bar(a: Array<T>): Array<T?> = null!!
fun test1(a: Array<out Int>) {
val r: Array<out Int?> = bar(a)
val r: Array<out Int?> = <!INITIALIZER_TYPE_MISMATCH!>bar(a)<!>
val t = bar(a)
t checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Array<out Int?>>() }
}
@@ -13,7 +13,7 @@ fun test1(a: Array<out Int>) {
fun <T: Any> foo(l: Array<T>): Array<Array<T?>> = null!!
fun test2(a: Array<out Int>) {
val r: Array<out Array<out Int?>> = foo(a)
val r: Array<out Array<out Int?>> = <!INITIALIZER_TYPE_MISMATCH!>foo(a)<!>
val t = foo(a)
t checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Array<out Array<out Int?>>>() }
}
compiler/testData/diagnostics/tests/inference/capturedTypes/expectedTypeMismatchWithInVariance.fir.kt
Vendored
+1 -1
View File
@@ -5,6 +5,6 @@ fun <T> foo(a1: Array<T>, a2: Array<out T>): T = null!!
fun test(a1: Array<in Int>, a2: Array<Int>) {
val c: Int = foo(a1, a2)
val c: Int = <!INITIALIZER_TYPE_MISMATCH!>foo(a1, a2)<!>
}
compiler/testData/diagnostics/tests/inference/coercionToUnit/noCoercion.fir.kt
Vendored
+2 -2
View File
@@ -10,9 +10,9 @@ fun noCoercionLastExpressionUsedAsReturnArgument() {
}
fun noCoercionBlockHasExplicitType() {
val b: () -> Int = {
val b: () -> Int = <!INITIALIZER_TYPE_MISMATCH!>{
if (true) 42
}
}<!>
}
fun noCoercionBlockHasExplicitReturn() {
compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/basic.fir.kt
Vendored
+2 -2
View File
@@ -138,7 +138,7 @@ fun main() {
* K <: (C) -> Unit -> TypeVariable(_RP1) >: C
* K == (B) -> Unit -> TypeVariable(_RP1) == B
*/
val x17: (C) -> Unit = selectB(id { <!DEBUG_INFO_EXPRESSION_TYPE("B")!>it<!> }, id { it }, id<(B) -> Unit> { x -> x })
val x17: (C) -> Unit = <!INITIALIZER_TYPE_MISMATCH!>selectB(id { <!DEBUG_INFO_EXPRESSION_TYPE("B")!>it<!> }, id { it }, id<(B) -> Unit> { x -> x })<!>
val x18: (C) -> Unit = select(id { <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }, { <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }, id<(B) -> Unit> { x -> x })
// Resolution of extension/non-extension functions combination
@@ -153,7 +153,7 @@ fun main() {
// Convert to extension lambda is impossible because the lambda parameter types aren't specified explicitly
select(id(fun String.(x: String) {}), id(fun(x: String, y: String) { }), { x, y -> x })
select(id(id(fun(x: String, y: String) { }), <!TOO_MANY_ARGUMENTS!>fun String.(x: String) {}<!>), { x, y -> x })
val x26: Int.(String) -> Int = fun (x: String) = 10 // it must be error, see KT-38439
val x26: Int.(String) -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (x: String) = 10<!> // it must be error, see KT-38439
// Receiver must be specified in anonymous function declaration
val x27: Int.(String) -> Int = id(fun (x: String) = 10)
select(id<Int.(String) -> Unit> {}, { x: Int, y: String -> x })
compiler/testData/diagnostics/tests/inference/constraints/kt6320.fir.kt
Vendored
+1 -1
View File
@@ -16,6 +16,6 @@ class C<X, Z, Y : X>
class D<X, Z, Y : X>(foo: C<X, Z, Y>) {
fun test(a: C<Y, Y, Y>) {
val d: D<X, Y, Y> = D(a)
val d: D<X, Y, Y> = <!INITIALIZER_TYPE_MISMATCH!>D(a)<!>
}
}
compiler/testData/diagnostics/tests/inference/dependantOnVariance.fir.kt
Vendored
+7 -7
View File
@@ -25,17 +25,17 @@ fun test1(int: Int, any: Any) {
val a5 : MyList<in Int> = getMyListToWriteTo(any)
val a6 : MyList<in Any> = getMyList<Int>(int)
val a6 : MyList<in Any> = <!INITIALIZER_TYPE_MISMATCH!>getMyList<Int>(int)<!>
val a7 : MyList<in Any> = getMyList(int)
val a8 : MyList<in Any> = getMyListToReadFrom<Int>(int)
val a9 : MyList<in Any> = getMyListToReadFrom(int)
val a8 : MyList<in Any> = <!INITIALIZER_TYPE_MISMATCH!>getMyListToReadFrom<Int>(int)<!>
val a9 : MyList<in Any> = <!INITIALIZER_TYPE_MISMATCH!>getMyListToReadFrom(int)<!>
val a10 : MyList<out Int> = getMyList<Any>(any)
val a11 : MyList<out Int> = getMyList(any)
val a10 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH!>getMyList<Any>(any)<!>
val a11 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH!>getMyList(any)<!>
val a12 : MyList<out Int> = getMyListToWriteTo<Any>(any)
val a13 : MyList<out Int> = getMyListToWriteTo(any)
val a12 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH!>getMyListToWriteTo<Any>(any)<!>
val a13 : MyList<out Int> = <!INITIALIZER_TYPE_MISMATCH!>getMyListToWriteTo(any)<!>
useMyList(getMyList(int), int)
useMyList(getMyList(any), int)
compiler/testData/diagnostics/tests/inference/kt1293.fir.kt
Vendored
+1 -1
View File
@@ -5,7 +5,7 @@ package kt1293
fun main() {
val intArray = arrayOfNulls<Int>(10)
val i : Int = intArray[0]
val i : Int = <!INITIALIZER_TYPE_MISMATCH!>intArray[0]<!>
requiresInt(<!ARGUMENT_TYPE_MISMATCH!>intArray[0]<!>)
}
compiler/testData/diagnostics/tests/inference/lambdaInValInitializerWithAnonymousFunctions.fir.kt
Vendored
+2 -2
View File
@@ -5,5 +5,5 @@ val test2f: suspend Any.() -> Unit = fun Any.() {}
// This is a bug in the old inference and should be fixed in new inference
// see "Fix anonymous function literals handling in type checker" for more details
val test3f: suspend Any.(Int) -> Int = fun (k: Int) = k + 1
val test4f: SuspendFn = fun Any.() {}
val test3f: suspend Any.(Int) -> Int = <!INITIALIZER_TYPE_MISMATCH!>fun (k: Int) = k + 1<!>
val test4f: SuspendFn = <!INITIALIZER_TYPE_MISMATCH!>fun Any.() {}<!>
compiler/testData/diagnostics/tests/inference/regressions/kt1127.fir.kt
Vendored
+1 -1
View File
@@ -6,5 +6,5 @@ package d
fun <T> asList(t: T) : List<T>? {}
fun main() {
val list : List<String> = asList("")
val list : List<String> = <!INITIALIZER_TYPE_MISMATCH!>asList("")<!>
}
compiler/testData/diagnostics/tests/inference/regressions/kt2883.fir.kt
Vendored
+2 -2
View File
@@ -22,12 +22,12 @@ fun test() {
doAction { bar(12) }
val u: Unit = bar(11)
val u: Unit = <!INITIALIZER_TYPE_MISMATCH!>bar(11)<!>
}
fun testWithoutInference(col: MutableCollection<Int>) {
doAction { col.add(2) }
val u: Unit = col.add(2)
val u: Unit = <!INITIALIZER_TYPE_MISMATCH!>col.add(2)<!>
}
compiler/testData/diagnostics/tests/inference/tooEagerSmartcast.fir.kt
Vendored
+1 -1
View File
@@ -20,7 +20,7 @@ fun <X> InvBase<X>.myLastInv(): X = TODO()
fun <T> fooInv(x: InvBase<T>) {
if (x is InvDerived<*>) {
val l: T = x.<!INAPPLICABLE_CANDIDATE!>myLastInv<!>() // required T, found Cap(*). Only in NI
val l: T = <!INITIALIZER_TYPE_MISMATCH!>x.<!INAPPLICABLE_CANDIDATE!>myLastInv<!>()<!> // required T, found Cap(*). Only in NI
}
}
compiler/testData/diagnostics/tests/inference/typeInferenceExpectedTypeMismatch.fir.kt
Vendored
+2 -2
View File
@@ -4,7 +4,7 @@ package typeInferenceExpectedTypeMismatch
import java.util.*
fun test() {
val s : Set<Int> = newList()
val s : Set<Int> = <!INITIALIZER_TYPE_MISMATCH!>newList()<!>
use(s)
}
@@ -35,7 +35,7 @@ fun <T> bar(o: Out<T>, i: In<T>): Two<T, T> = throw Exception("$o $i")
fun test2(outA: Out<A>, inC: In<C>) {
bar(outA, <!ARGUMENT_TYPE_MISMATCH!>inC<!>)
val b: Two<A, B> = bar(outA, <!ARGUMENT_TYPE_MISMATCH!>inC<!>)
val b: Two<A, B> = <!INITIALIZER_TYPE_MISMATCH!>bar(outA, <!ARGUMENT_TYPE_MISMATCH!>inC<!>)<!>
use(b)
}
compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsIfUnknownParameters.fir.kt
Vendored
+1 -1
View File
@@ -8,5 +8,5 @@ class Client<T, X: Base<T>>(x: X)
fun test() {
val c = Client(StringBase()) // Type inference fails here for T.
val i : Int = c
val i : Int = <!INITIALIZER_TYPE_MISMATCH!>c<!>
}
compiler/testData/diagnostics/tests/j+k/sam/referenceToSamFunctionAgainstExpectedType.fir.kt
Vendored
+1 -1
View File
@@ -17,7 +17,7 @@ public class Inv<T> {
// FILE: test.kt
fun test(inv: Inv<String>) {
val m: ((String) -> String) -> Inv<String> = inv::map
val m: ((String) -> String) -> Inv<String> = <!INITIALIZER_TYPE_MISMATCH!>inv::map<!>
<!INAPPLICABLE_CANDIDATE!>take<!>(inv::<!UNRESOLVED_REFERENCE!>map<!>)
}
compiler/testData/diagnostics/tests/library/Collections.fir.kt
Vendored
+8 -8
View File
@@ -8,7 +8,7 @@ fun <T> testCollection(c: Collection<T>, t: T) {
val iterator: Iterator<T> = c.iterator()
c.containsAll(c)
val mutableIterator: MutableIterator<T> = c.iterator()
val mutableIterator: MutableIterator<T> = <!INITIALIZER_TYPE_MISMATCH!>c.iterator()<!>
c.<!UNRESOLVED_REFERENCE!>add<!>(t)
c.<!UNRESOLVED_REFERENCE!>remove<!>(1)
c.<!UNRESOLVED_REFERENCE!>addAll<!>(c)
@@ -45,9 +45,9 @@ fun <T> testList(l: List<T>, t: T) {
val value: T = l.<!UNRESOLVED_REFERENCE!>set<!>(1, t)
l.<!UNRESOLVED_REFERENCE!>add<!>(1, t)
l.<!UNRESOLVED_REFERENCE!>remove<!>(1)
val mutableListIterator: MutableListIterator<T> = l.listIterator()
val mutableListIterator1: MutableListIterator<T> = l.listIterator(1)
val mutableList: MutableList<T> = l.subList(1, 2)
val mutableListIterator: MutableListIterator<T> = <!INITIALIZER_TYPE_MISMATCH!>l.listIterator()<!>
val mutableListIterator1: MutableListIterator<T> = <!INITIALIZER_TYPE_MISMATCH!>l.listIterator(1)<!>
val mutableList: MutableList<T> = <!INITIALIZER_TYPE_MISMATCH!>l.subList(1, 2)<!>
}
fun <T> testMutableList(l: MutableList<T>, t: T) {
@@ -66,7 +66,7 @@ fun <T> testSet(s: Set<T>, t: T) {
val iterator: Iterator<T> = s.iterator()
s.containsAll(s)
val mutableIterator: MutableIterator<T> = s.iterator()
val mutableIterator: MutableIterator<T> = <!INITIALIZER_TYPE_MISMATCH!>s.iterator()<!>
s.<!UNRESOLVED_REFERENCE!>add<!>(t)
s.<!UNRESOLVED_REFERENCE!>remove<!>(1)
s.<!UNRESOLVED_REFERENCE!>addAll<!>(s)
@@ -97,9 +97,9 @@ fun <K, V> testMap(m: Map<K, V>) {
val collection: Collection<V> = m.values
val set1: Set<Map.Entry<K, V>> = m.entries
val mutableSet: MutableSet<K> = m.keys
val mutableCollection: MutableCollection<V> = m.values
val mutableSet1: MutableSet<MutableMap.MutableEntry<K, V>> = m.entries
val mutableSet: MutableSet<K> = <!INITIALIZER_TYPE_MISMATCH!>m.keys<!>
val mutableCollection: MutableCollection<V> = <!INITIALIZER_TYPE_MISMATCH!>m.values<!>
val mutableSet1: MutableSet<MutableMap.MutableEntry<K, V>> = <!INITIALIZER_TYPE_MISMATCH!>m.entries<!>
}
fun <K, V> testMutableMap(m: MutableMap<K, V>) {
compiler/testData/diagnostics/tests/multimodule/duplicateClass/sameClassNameDifferentPackages.fir.kt
Vendored
+1 -1
View File
@@ -18,5 +18,5 @@ import p.*
class A
fun test() {
val a: A = B().a
val a: A = <!INITIALIZER_TYPE_MISMATCH!>B().a<!>
}
compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/AssertNotNull.fir.kt
Vendored
+1 -1
View File
@@ -34,6 +34,6 @@ fun main() {
}
}
val f : String = a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!>
val f : String = <!INITIALIZER_TYPE_MISMATCH!>a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!><!>
checkSubtype<String>(<!ARGUMENT_TYPE_MISMATCH!>a<!UNNECESSARY_NOT_NULL_ASSERTION!>!!<!><!>)
}
compiler/testData/diagnostics/tests/nullableTypes/inferenceFlexibleTToNullable.fir.kt
Vendored
+2 -2
View File
@@ -32,12 +32,12 @@ public class Foo<T> {
// FILE: main.kt
fun <T> bar(n: Number?, d: T, e: T) {
val a: Number = Foo.simpleId(n)
val a: Number = <!INITIALIZER_TYPE_MISMATCH!>Foo.simpleId(n)<!>
val b: Number? = Foo.simpleId(n)
val c = Foo.simpleId(n)
val x4 = Foo(if (true) 10 else null)
val x5: Number = x4.produceT()
val x5: Number = <!INITIALIZER_TYPE_MISMATCH!>x4.produceT()<!>
val x6: Number? = x4.produceT()
val x7 = x4.produceT()
val x8 = x4.produceNotNullT()
compiler/testData/diagnostics/tests/numbers/doublesInSimpleConstraints.fir.kt
Vendored
+1 -1
View File
@@ -21,5 +21,5 @@ fun test() {
val d = either(11, 2.3)
checkSubtype<Any>(d)
val e: Float = id(1)
val e: Float = <!INITIALIZER_TYPE_MISMATCH!>id(1)<!>
}
compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.fir.kt
Vendored
+3 -3
View File
@@ -17,9 +17,9 @@ fun <T> otherGeneric(l: List<T>) {}
fun test() {
val a: Byte = id(1)
val b: Byte = id(300)
val b: Byte = <!INITIALIZER_TYPE_MISMATCH!>id(300)<!>
val c: Int = id(9223372036854775807)
val c: Int = <!INITIALIZER_TYPE_MISMATCH!>id(9223372036854775807)<!>
val d = id(22)
checkSubtype<Int>(d)
@@ -29,7 +29,7 @@ fun test() {
val f: Byte = either(1, 2)
val g: Byte = either(1, 300)
val g: Byte = <!INITIALIZER_TYPE_MISMATCH!>either(1, 300)<!>
other(<!ARGUMENT_TYPE_MISMATCH!>11<!>)
compiler/testData/diagnostics/tests/objects/kt5527.fir.kt
Vendored
+3 -3
View File
@@ -7,13 +7,13 @@ class A {
}
fun foo() {
val i1: Int = Boo
val i2: Int = A.Boo
val i1: Int = <!INITIALIZER_TYPE_MISMATCH!>Boo<!>
val i2: Int = <!INITIALIZER_TYPE_MISMATCH!>A.Boo<!>
useInt(<!ARGUMENT_TYPE_MISMATCH!>Boo<!>)
useInt(A.<!ARGUMENT_TYPE_MISMATCH!>Boo<!>)
}
fun bar() {
val i1: Int = Unit
val i1: Int = <!INITIALIZER_TYPE_MISMATCH!>Unit<!>
useInt(<!ARGUMENT_TYPE_MISMATCH!>Unit<!>)
}
compiler/testData/diagnostics/tests/platformTypes/methodCall/singleton.fir.kt
Vendored
+1 -1
View File
@@ -5,6 +5,6 @@ interface Foo
fun test() {
var nullable: Foo? = null
val foo: Collection<Foo> = java.util.Collections.singleton(nullable)
val foo: Collection<Foo> = <!INITIALIZER_TYPE_MISMATCH!>java.util.Collections.singleton(nullable)<!>
val foo1: Collection<Foo> = java.util.Collections.singleton(nullable!!)
}
compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawTypeInUpperBound.fir.kt
Vendored
+1 -1
View File
@@ -31,7 +31,7 @@ fun foo(x: B<*>) {
// Raw(B).field erased to A<Any!>..A<out Any!>?
Test.rawB.field = A<String>()
val anyA: A<Any> = Test.rawB.field
val anyA: A<Any> = <!INITIALIZER_TYPE_MISMATCH!>Test.rawB.field<!>
// FIR doesn't work here, because
// field has a type of just 'A' and it's not clear why should it accept 'String' at consume
compiler/testData/diagnostics/tests/regressions/TypeMismatchOnUnaryOperations.fir.kt
Vendored
+7 -7
View File
@@ -2,15 +2,15 @@
fun main() {
val a : Int? = null;
var v = 1
val b : String = v;
val f : String = a!!;
val b : String = <!INITIALIZER_TYPE_MISMATCH!>v<!>;
val f : String = <!INITIALIZER_TYPE_MISMATCH!>a!!<!>;
val g : String = v++;
val g1 : String = ++v;
val h : String = v--;
val h1 : String = --v;
val i : String = !true;
val j : String = foo@ true;
val k : String = foo@ bar@ true;
val l : String = -1;
val m : String = +1;
val i : String = <!INITIALIZER_TYPE_MISMATCH!>!true<!>;
val j : String = <!INITIALIZER_TYPE_MISMATCH!>foo@ true<!>;
val k : String = <!INITIALIZER_TYPE_MISMATCH!>foo@ bar@ true<!>;
val l : String = <!INITIALIZER_TYPE_MISMATCH!>-1<!>;
val m : String = <!INITIALIZER_TYPE_MISMATCH!>+1<!>;
}
compiler/testData/diagnostics/tests/regressions/kt235.fir.kt
Vendored
+12 -12
View File
@@ -4,29 +4,29 @@ package kt235
fun main() {
val array = MyArray()
val f: () -> String = {
val f: () -> String = <!INITIALIZER_TYPE_MISMATCH!>{
array[2] = 23 //error: Type mismatch: inferred type is Int (!!!) but String was expected
}
val g: () -> String = {
}<!>
val g: () -> String = <!INITIALIZER_TYPE_MISMATCH!>{
var x = 1
x += 2 //no error, but it should be here
}
val h: () -> String = {
}<!>
val h: () -> String = <!INITIALIZER_TYPE_MISMATCH!>{
var x = 1
x = 2 //the same
}
}<!>
val array1 = MyArray1()
val i: () -> String = {
val i: () -> String = <!INITIALIZER_TYPE_MISMATCH!>{
array1[2] = 23
}
}<!>
val fi: () -> String = {
val fi: () -> String = <!INITIALIZER_TYPE_MISMATCH!>{
array[2] = 23
}
val gi: () -> String = {
}<!>
val gi: () -> String = <!INITIALIZER_TYPE_MISMATCH!>{
var x = 1
x += 21
}
}<!>
var m: MyNumber = MyNumber()
val a: () -> MyNumber = {
compiler/testData/diagnostics/tests/regressions/kt2768.fir.kt
Vendored
+2 -2
View File
@@ -6,13 +6,13 @@ fun main() {
val bytePos = 128.toByte() // Byte.MAX_VALUE + 1
assertEquals(-128, bytePos.toInt()) // correct, wrapped to Byte.MIN_VALUE
val byteNeg: Byte = -bytePos // should not compile, byteNeg should be Int
val byteNeg: Byte = <!INITIALIZER_TYPE_MISMATCH!>-bytePos<!> // should not compile, byteNeg should be Int
assertEquals(128, byteNeg.toInt()) // passes, should not be possible
val shortPos = 32768.toShort() // Short.MAX_VALUE + 1
assertEquals(-32768, shortPos.toInt()) // correct, wrapped to Short.MIN_VALUE
val shortNeg: Short = -shortPos // should not compile, shortNeg should be Int
val shortNeg: Short = <!INITIALIZER_TYPE_MISMATCH!>-shortPos<!> // should not compile, shortNeg should be Int
assertEquals(32768, shortNeg.toInt()) // passes, should not be possible
(-128).toByte()
compiler/testData/diagnostics/tests/regressions/kt2956.fir.kt
Vendored
+1 -1
View File
@@ -1 +1 @@
val a: String = Nothing
val a: String = <!INITIALIZER_TYPE_MISMATCH!>Nothing<!>
compiler/testData/diagnostics/tests/regressions/kt30245.fir.kt
Vendored
+2 -2
View File
@@ -80,8 +80,8 @@ fun test2() { // to extension lambda 1
val e = E.VALUE
val w27 = W2(<!ARGUMENT_TYPE_MISMATCH!>when (e) { E.VALUE -> { s: String -> <!NO_THIS!>this<!> + s.length } }<!>) // oi- ni+
val w27a = W2(<!ARGUMENT_TYPE_MISMATCH!>when (e) { E.VALUE -> { s -> <!NO_THIS!>this<!> + s.<!UNRESOLVED_REFERENCE!>length<!> } }<!>) // oi+ ni+
val i27: E1 = when (e) { E.VALUE -> { s: String -> <!NO_THIS!>this<!> + s.length } } // oi+ ni+
val i27a: E1 = when (e) { E.VALUE -> { s -> <!NO_THIS!>this<!> + s.<!UNRESOLVED_REFERENCE!>length<!> } } // oi+ ni+
val i27: E1 = <!INITIALIZER_TYPE_MISMATCH!>when (e) { E.VALUE -> { s: String -> <!NO_THIS!>this<!> + s.length } }<!> // oi+ ni+
val i27a: E1 = <!INITIALIZER_TYPE_MISMATCH!>when (e) { E.VALUE -> { s -> <!NO_THIS!>this<!> + s.<!UNRESOLVED_REFERENCE!>length<!> } }<!> // oi+ ni+
val w28 = W2 { i: Int, s -> <!ARGUMENT_TYPE_MISMATCH!>i <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> s.<!UNRESOLVED_REFERENCE!>length<!><!> } // oi- ni-
val i28: E1 = id { i: Int, s -> i <!OVERLOAD_RESOLUTION_AMBIGUITY!>+<!> s.<!UNRESOLVED_REFERENCE!>length<!> } // oi- ni-
compiler/testData/diagnostics/tests/regressions/kt312.fir.kt
Vendored
+1 -1
View File
@@ -6,5 +6,5 @@ fun <T> Array<out T>.safeGet(index : Int) : T? {
}
val args : Array<String> = Array<String>(1, {""})
val name : String = args.safeGet<String>(0) // No error, must be type mismatch
val name : String = <!INITIALIZER_TYPE_MISMATCH!>args.safeGet<String>(0)<!> // No error, must be type mismatch
val name1 : String? = args.safeGet(0)
compiler/testData/diagnostics/tests/resolve/overloadConflicts/originalExamples.fir.kt
Vendored
+1 -1
View File
@@ -8,7 +8,7 @@ fun overloadedFun1(c: Any = "", b: String = "", f: Any = "") = Right
fun overloadedFun1(b: Any = "", c: Any = "", e: String = "") = Wrong
val test1: Right = overloadedFun1(b = "")
val test1a: Wrong = overloadedFun1(b = "")
val test1a: Wrong = <!INITIALIZER_TYPE_MISMATCH!>overloadedFun1(b = "")<!>
fun overloadedFun2(a: String, b: Any = "") = Right
fun overloadedFun2(a: Any, b: String = "") = Wrong
compiler/testData/diagnostics/tests/scopes/inheritance/methodsPriority.fir.kt
Vendored
+1 -1
View File
@@ -20,7 +20,7 @@ fun test() {
class B: A() {
init {
val a: Int = foo() // todo
val a: Int = <!INITIALIZER_TYPE_MISMATCH!>foo()<!> // todo
}
}
}
compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_after.fir.kt
Vendored
+2 -2
View File
@@ -12,14 +12,14 @@ open class A<T> : J() {
init {
foo()
bar()
val a: Int = baz()
val a: Int = <!INITIALIZER_TYPE_MISMATCH!>baz()<!>
val b: T = baz()
}
fun test1() {
foo()
bar()
val a: Int = baz()
val a: Int = <!INITIALIZER_TYPE_MISMATCH!>baz()<!>
val b: T = baz()
}
compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_before.fir.kt
Vendored
+2 -2
View File
@@ -12,14 +12,14 @@ open class A<T> : J() {
init {
foo()
bar()
val a: Int = baz()
val a: Int = <!INITIALIZER_TYPE_MISMATCH!>baz()<!>
val b: T = baz()
}
fun test1() {
foo()
bar()
val a: Int = baz()
val a: Int = <!INITIALIZER_TYPE_MISMATCH!>baz()<!>
val b: T = baz()
}
compiler/testData/diagnostics/tests/scopes/inheritance/statics/localVsStatic.fir.kt
Vendored
+1 -1
View File
@@ -21,7 +21,7 @@ fun test() {
class B: A() {
init {
val a: Int = foo() // todo
val a: Int = <!INITIALIZER_TYPE_MISMATCH!>foo()<!> // todo
}
}
}
compiler/testData/diagnostics/tests/secondaryConstructors/resolvePropertyInitializerWithoutPrimary.fir.kt
Vendored
+1 -1
View File
@@ -1,4 +1,4 @@
class A {
val prop: Int = ""
val prop: Int = <!INITIALIZER_TYPE_MISMATCH!>""<!>
constructor()
}
compiler/testData/diagnostics/tests/smartCasts/inference/intersectionTypes.fir.kt
Vendored
+1 -1
View File
@@ -31,7 +31,7 @@ fun test(a: A, b: B, c: C) {
val k = three(a, b, c)
checkSubtype<A>(k)
checkSubtype<B>(<!ARGUMENT_TYPE_MISMATCH!>k<!>)
val l: Int = three(a, b, c)
val l: Int = <!INITIALIZER_TYPE_MISMATCH!>three(a, b, c)<!>
use(d, e, f, g, h, k, l)
}
compiler/testData/diagnostics/tests/smartCasts/safecalls/anotherVal.fir.kt
Vendored
+1 -1
View File
@@ -3,6 +3,6 @@
fun calc(x: List<String>?, y: Int?): Int {
x?.get(y!! - 1)
// y!! above should not provide smart cast here
val yy: Int = y
val yy: Int = <!INITIALIZER_TYPE_MISMATCH!>y<!>
return yy + (x?.size ?: 0)
}
compiler/testData/diagnostics/tests/subtyping/findClosestCorrespondingSupertype.fir.kt
Vendored
+1 -1
View File
@@ -6,5 +6,5 @@ interface B : A, X<Int>
fun foo(x: B) {
// Checks that when checking subtypes we search closes corresponding constructor (e.g. with BFS)
val y: X<Int> = x
val y: X<Int> = <!INITIALIZER_TYPE_MISMATCH!>x<!>
}
compiler/testData/diagnostics/tests/typealias/privateInFile.fir.kt
Vendored
+4 -4
View File
@@ -6,16 +6,16 @@ private class C {
private typealias TA = C
private val test1: C = <!HIDDEN!>C<!>()
private val test1co: C.Companion = C
private val test1co: C.Companion = <!INITIALIZER_TYPE_MISMATCH!>C<!>
private val test2: TA = TA(<!NO_VALUE_FOR_PARAMETER!>)<!>
private val test2: TA = <!INITIALIZER_TYPE_MISMATCH!>TA(<!NO_VALUE_FOR_PARAMETER!>)<!><!>
private val test2co = TA
// FILE: file2.kt
private val test1: C = C()
private val test1co: C.Companion = C
private val test1co: C.Companion = <!INITIALIZER_TYPE_MISMATCH!>C<!>
private val test2: TA = TA(<!NO_VALUE_FOR_PARAMETER!>)<!>
private val test2: TA = <!INITIALIZER_TYPE_MISMATCH!>TA(<!NO_VALUE_FOR_PARAMETER!>)<!><!>
private val test2co = TA
<!REDECLARATION!>private class C<!>
compiler/testData/diagnostics/tests/unsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.fir.kt
Vendored
+1 -1
View File
@@ -60,6 +60,6 @@ const val constVal = 10
val globalVariableWithGetter: Int get() = 0
val prop: UByte = 255
val prop: UByte = <!INITIALIZER_TYPE_MISMATCH!>255<!>
fun Int.myPlus(other: Int): Int = this + other
compiler/testData/diagnostics/tests/unsignedTypes/explicitUnsignedLongTypeCheck.fir.kt
Vendored
+2 -2
View File
@@ -1,7 +1,7 @@
// !DIAGNOSTICS: -UNUSED_PARAMETER
val a0: Int = 1uL
val a1: UInt = 1uL
val a0: Int = <!INITIALIZER_TYPE_MISMATCH!>1uL<!>
val a1: UInt = <!INITIALIZER_TYPE_MISMATCH!>1uL<!>
val a3: ULong = 1uL
val a4 = 1UL + 2UL
val a5 = <!UNRESOLVED_REFERENCE!>-<!>1UL
compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOverflowSignedBorder.fir.kt
Vendored
+1 -1
View File
@@ -21,5 +21,5 @@ fun test() {
takeUByte(0xFFu)
}
val s1: UByte = 256u
val s1: UByte = <!INITIALIZER_TYPE_MISMATCH!>256u<!>
val s2 = <!INT_LITERAL_OUT_OF_RANGE!>18446744073709551616u<!>
compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsTypeCheck.fir.kt
Vendored
+2 -2
View File
@@ -1,7 +1,7 @@
val a0: Any = 1u
val n0: Number = 1u
val n0: Number = <!INITIALIZER_TYPE_MISMATCH!>1u<!>
val c0: Comparable<*> = 1u
val c1: Comparable<UInt> = 1u
@@ -11,7 +11,7 @@ val u1: UInt? = 1u
val u2: UInt? = u0
val u3: UInt? = u1
val i0: Int = 1u
val i0: Int = <!INITIALIZER_TYPE_MISMATCH!>1u<!>
val m0 = <!UNRESOLVED_REFERENCE!>-<!>1u
val m1: UInt = <!UNRESOLVED_REFERENCE!>-<!>1u
compiler/testData/diagnostics/tests/when/kt9929.fir.kt
Vendored
+2 -2
View File
@@ -1,5 +1,5 @@
// !WITH_NEW_INFERENCE
val test: Int = if (true) {
val test: Int = <!INITIALIZER_TYPE_MISMATCH!>if (true) {
when (2) {
1 -> 1
else -> null
@@ -7,4 +7,4 @@ val test: Int = if (true) {
}
else {
2
}
}<!>
compiler/testData/diagnostics/tests/when/kt9972.fir.kt
Vendored
+2 -2
View File
@@ -21,9 +21,9 @@ fun test1(): Int {
}
fun test2(): Int {
val x: String = when {
val x: String = <!INITIALIZER_TYPE_MISMATCH!>when {
true -> Any()
else -> null
} ?: return 0
} ?: return 0<!>
return x.hashCode()
}
compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWithErrors.fir.kt
Vendored
+2 -2
View File
@@ -19,6 +19,6 @@ val test1 = generate {
yield(A)
}
val test2: Int = generate {
val test2: Int = <!INITIALIZER_TYPE_MISMATCH!>generate {
yield(A())
}
}<!>
compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndLowPriority.fir.kt
Vendored
+1 -1
View File
@@ -18,7 +18,7 @@ public fun <K, V> Map<K, V>.get1(key: Any?): Int = null!!
public fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> K, V> Map<out K, V>.get1(key: K): V? = null!!
fun test(map: Map<Int, String>) {
val a: Int = listOf(1).contains1("")
val a: Int = <!INITIALIZER_TYPE_MISMATCH!>listOf(1).contains1("")<!>
val b: Boolean = listOf(1).contains1(1)
val c: String? = map.get1("")
compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/maps.fir.kt
Vendored
+6 -6
View File
@@ -26,8 +26,8 @@ fun hashMapTest() {
val b4: Map<String?, Int?> = x
val b5: Map<String, Int?> = x
val b6: Int = x[""]
val b7: Int = x.get("")
val b6: Int = <!INITIALIZER_TYPE_MISMATCH!>x[""]<!>
val b7: Int = <!INITIALIZER_TYPE_MISMATCH!>x.get("")<!>
val b8: Int? = x.get("")
}
@@ -50,8 +50,8 @@ fun treeMapTest() {
val b4: Map<String?, Int?> = x
val b5: Map<String, Int?> = x
val b6: Int = x[""]
val b7: Int = x.get("")
val b6: Int = <!INITIALIZER_TYPE_MISMATCH!>x[""]<!>
val b7: Int = <!INITIALIZER_TYPE_MISMATCH!>x.get("")<!>
val b8: Int? = x.get("")
}
@@ -74,8 +74,8 @@ fun concurrentHashMapTest() {
val b4: Map<String?, Int?> = x
val b5: Map<String, Int?> = x
val b6: Int = x[""]
val b7: Int = x.get("")
val b6: Int = <!INITIALIZER_TYPE_MISMATCH!>x[""]<!>
val b7: Int = <!INITIALIZER_TYPE_MISMATCH!>x.get("")<!>
val b8: Int? = x.get("")
}
compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableKey.fir.kt
Vendored
+7 -7
View File
@@ -23,11 +23,11 @@ fun hashMapTest() {
val b2: MutableMap<String?, Int> = x
val b3: Map<String?, Int> = x
val b4: Map<String?, Int?> = x
val b5: Map<String, Int?> = x
val b5: Map<String, Int?> = <!INITIALIZER_TYPE_MISMATCH!>x<!>
val b6: Int = x[""]
val b7: Int = x[null]
val b8: Int = x.get("")
val b6: Int = <!INITIALIZER_TYPE_MISMATCH!>x[""]<!>
val b7: Int = <!INITIALIZER_TYPE_MISMATCH!>x[null]<!>
val b8: Int = <!INITIALIZER_TYPE_MISMATCH!>x.get("")<!>
val b9: Int? = x.get("")
}
@@ -48,10 +48,10 @@ fun treeMapTest() {
val b2: MutableMap<String?, Int> = x
val b3: Map<String?, Int> = x
val b4: Map<String?, Int?> = x
val b5: Map<String, Int?> = x
val b5: Map<String, Int?> = <!INITIALIZER_TYPE_MISMATCH!>x<!>
val b6: Int = x[""]
val b7: Int = x.get("")
val b6: Int = <!INITIALIZER_TYPE_MISMATCH!>x[""]<!>
val b7: Int = <!INITIALIZER_TYPE_MISMATCH!>x.get("")<!>
val b8: Int? = x.get("")
}
compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableValues.fir.kt
Vendored
+8 -8
View File
@@ -19,14 +19,14 @@ fun hashMapTest() {
x[""] = nullableInt
x[""] = 1
val b1: MutableMap<String, Int> = x
val b1: MutableMap<String, Int> = <!INITIALIZER_TYPE_MISMATCH!>x<!>
val b2: MutableMap<String, Int?> = x
val b3: Map<String, Int> = x
val b3: Map<String, Int> = <!INITIALIZER_TYPE_MISMATCH!>x<!>
val b4: Map<String, Int?> = x
val b5: Map<String?, Int?> = x
val b6: Int = x[""]
val b7: Int = x.get("")
val b6: Int = <!INITIALIZER_TYPE_MISMATCH!>x[""]<!>
val b7: Int = <!INITIALIZER_TYPE_MISMATCH!>x.get("")<!>
val b8: Int? = x.get("")
}
@@ -43,14 +43,14 @@ fun treeMapTest() {
x[""] = nullableInt
x[""] = 1
val b1: MutableMap<String, Int> = x
val b1: MutableMap<String, Int> = <!INITIALIZER_TYPE_MISMATCH!>x<!>
val b2: MutableMap<String, Int?> = x
val b3: Map<String, Int> = x
val b3: Map<String, Int> = <!INITIALIZER_TYPE_MISMATCH!>x<!>
val b4: Map<String, Int?> = x
val b5: Map<String?, Int?> = x
val b6: Int = x[""]
val b7: Int = x.get("")
val b6: Int = <!INITIALIZER_TYPE_MISMATCH!>x[""]<!>
val b7: Int = <!INITIALIZER_TYPE_MISMATCH!>x.get("")<!>
val b8: Int? = x.get("")
}
compiler/testData/diagnostics/testsWithStdLib/regression/ea70485_functionTypeInheritor.fir.kt
Vendored
+1 -1
View File
@@ -13,5 +13,5 @@ fun test() {
}
fun test2() {
val f: Ext = {}
val f: Ext = <!INITIALIZER_TYPE_MISMATCH!>{}<!>
}
compiler/testData/diagnostics/testsWithStdLib/tryCatch/assignTry.fir.kt
Vendored
+2 -2
View File
@@ -6,7 +6,7 @@ class ExcA : Exception()
class ExcB : Exception()
fun test2() {
val s: String? = try {
val s: String? = <!INITIALIZER_TYPE_MISMATCH!>try {
""
}
catch (e: ExcA) {
@@ -14,7 +14,7 @@ fun test2() {
}
catch (e: ExcB) {
10
}
}<!>
s<!UNSAFE_CALL!>.<!>length
}

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