diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java index 250878d0c82..126fb2a9750 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java @@ -12680,12 +12680,24 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti runTest("compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorType.kt"); } + @Test + @TestMetadata("specialCallsWithCallableReferencesErrorTypeUnrestricted.kt") + public void testSpecialCallsWithCallableReferencesErrorTypeUnrestricted() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorTypeUnrestricted.kt"); + } + @Test @TestMetadata("specialCallsWithCallableReferencesNonStrictOnlyInputTypes.kt") public void testSpecialCallsWithCallableReferencesNonStrictOnlyInputTypes() throws Exception { runTest("compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesNonStrictOnlyInputTypes.kt"); } + @Test + @TestMetadata("specialCallsWithCallableReferencesUnrestricted.kt") + public void testSpecialCallsWithCallableReferencesUnrestricted() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesUnrestricted.kt"); + } + @Test @TestMetadata("specialCallsWithLambdas.kt") public void testSpecialCallsWithLambdas() throws Exception { @@ -12706,12 +12718,6 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public void testViolating() throws Exception { runTest("compiler/testData/diagnostics/tests/inference/builderInference/constraints/violating.kt"); } - - @Test - @TestMetadata("withExpectedType.kt") - public void testWithExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/builderInference/constraints/withExpectedType.kt"); - } } @Nested diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java index 682b3cb20e8..bc21afea372 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java @@ -12680,12 +12680,24 @@ public class FirOldFrontendDiagnosticsWithLightTreeTestGenerated extends Abstrac runTest("compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorType.kt"); } + @Test + @TestMetadata("specialCallsWithCallableReferencesErrorTypeUnrestricted.kt") + public void testSpecialCallsWithCallableReferencesErrorTypeUnrestricted() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorTypeUnrestricted.kt"); + } + @Test @TestMetadata("specialCallsWithCallableReferencesNonStrictOnlyInputTypes.kt") public void testSpecialCallsWithCallableReferencesNonStrictOnlyInputTypes() throws Exception { runTest("compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesNonStrictOnlyInputTypes.kt"); } + @Test + @TestMetadata("specialCallsWithCallableReferencesUnrestricted.kt") + public void testSpecialCallsWithCallableReferencesUnrestricted() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesUnrestricted.kt"); + } + @Test @TestMetadata("specialCallsWithLambdas.kt") public void testSpecialCallsWithLambdas() throws Exception { @@ -12706,12 +12718,6 @@ public class FirOldFrontendDiagnosticsWithLightTreeTestGenerated extends Abstrac public void testViolating() throws Exception { runTest("compiler/testData/diagnostics/tests/inference/builderInference/constraints/violating.kt"); } - - @Test - @TestMetadata("withExpectedType.kt") - public void testWithExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/builderInference/constraints/withExpectedType.kt"); - } } @Nested diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java index c628cc2b910..778ffccfc1c 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java @@ -17587,18 +17587,78 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT runTest("compiler/testData/codegen/box/inference/builderInference/callableReferencesProperCompletion.kt"); } + @Test + @TestMetadata("capturedTypes.kt") + public void testCapturedTypes() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/capturedTypes.kt"); + } + + @Test + @TestMetadata("commonSuperType.kt") + public void testCommonSuperType() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperType.kt"); + } + + @Test + @TestMetadata("commonSuperTypeContravariant.kt") + public void testCommonSuperTypeContravariant() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeContravariant.kt"); + } + + @Test + @TestMetadata("commonSuperTypeCovariant.kt") + public void testCommonSuperTypeCovariant() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeCovariant.kt"); + } + + @Test + @TestMetadata("commonSuperTypeInvariant.kt") + public void testCommonSuperTypeInvariant() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeInvariant.kt"); + } + + @Test + @TestMetadata("commonSuperTypeNullable.kt") + public void testCommonSuperTypeNullable() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeNullable.kt"); + } + + @Test + @TestMetadata("intersect.kt") + public void testIntersect() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/intersect.kt"); + } + @Test @TestMetadata("kt41164.kt") public void testKt41164() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/kt41164.kt"); } + @Test + @TestMetadata("labaledCall.kt") + public void testLabaledCall() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/labaledCall.kt"); + } + @Test @TestMetadata("lackOfNullCheckOnNullableInsideBuild.kt") public void testLackOfNullCheckOnNullableInsideBuild() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/lackOfNullCheckOnNullableInsideBuild.kt"); } + @Test + @TestMetadata("memberScope.kt") + public void testMemberScope() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/memberScope.kt"); + } + + @Test + @TestMetadata("nullability.kt") + public void testNullability() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/nullability.kt"); + } + @Test @TestMetadata("propagateInferenceSessionIntoDeclarationAnalyzers.kt") public void testPropagateInferenceSessionIntoDeclarationAnalyzers() throws Exception { @@ -17617,6 +17677,18 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExpression.kt"); } + @Test + @TestMetadata("specialCallsWithCallableReferencesDontCareTypeInBlockExression.kt") + public void testSpecialCallsWithCallableReferencesDontCareTypeInBlockExression() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExression.kt"); + } + + @Test + @TestMetadata("specialCallsWithCallableReferencesDontRewriteAtSlice.kt") + public void testSpecialCallsWithCallableReferencesDontRewriteAtSlice() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontRewriteAtSlice.kt"); + } + @Test @TestMetadata("specialCallsWithCallableReferencesErrorType.kt") public void testSpecialCallsWithCallableReferencesErrorType() throws Exception { @@ -17682,6 +17754,12 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT public void testTopDownCompletionWithTwoBuilderInferenceCalls() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/topDownCompletionWithTwoBuilderInferenceCalls.kt"); } + + @Test + @TestMetadata("withExpectedType.kt") + public void testWithExpectedType() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/withExpectedType.kt"); + } } } diff --git a/compiler/testData/codegen/box/inference/builderInference/capturedTypes.kt b/compiler/testData/codegen/box/inference/builderInference/capturedTypes.kt new file mode 100644 index 00000000000..18303f73329 --- /dev/null +++ b/compiler/testData/codegen/box/inference/builderInference/capturedTypes.kt @@ -0,0 +1,44 @@ +// !LANGUAGE: +UnrestrictedBuilderInference +// WITH_RUNTIME + +// FILE: main.kt +import kotlin.experimental.ExperimentalTypeInference + +@UseExperimental(ExperimentalTypeInference::class) +fun build(@BuilderInference block: TestInterface.() -> Unit) {} + +@UseExperimental(ExperimentalTypeInference::class) +fun build2(@BuilderInference block: TestInterface.() -> Unit) {} + +interface TestInterface { + fun emit(r: R) + fun get(): R + fun getInv(): Inv + fun getOut(): Inv + fun getIn(): Inv +} + +class Inv + +fun captureOut(x: Inv): K = null as K +fun captureIn(x: Inv): K = null as K +fun capture(x: Inv): K = null as K + +fun box(): String { + build { + emit("") + getInv() + captureOut(getInv()) + captureIn(getInv()) + + capture(getOut()) + "" + } + build { + emit("") + capture(getIn()) + "" + } + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/inference/builderInference/commonSuperType.kt b/compiler/testData/codegen/box/inference/builderInference/commonSuperType.kt new file mode 100644 index 00000000000..6f46df75e6a --- /dev/null +++ b/compiler/testData/codegen/box/inference/builderInference/commonSuperType.kt @@ -0,0 +1,59 @@ +// !LANGUAGE: +UnrestrictedBuilderInference +// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE +// WITH_RUNTIME + +// FILE: Test.java + +class Test { + static T foo(T x) { return x; } +} + +// FILE: main.kt +import kotlin.experimental.ExperimentalTypeInference + +@UseExperimental(ExperimentalTypeInference::class) +fun build(@BuilderInference block: TestInterface.() -> Unit) {} + +@UseExperimental(ExperimentalTypeInference::class) +fun build2(@BuilderInference block: TestInterface.() -> Unit) {} + +class Inv + +interface TestInterface { + fun emit(r: R) + fun get(): R + fun getInv(): Inv +} + +fun id(x: U) = x +fun select(vararg x: E) = x[0] + +fun box(): String { + val ret = build { + emit("1") + Test.foo(get()) + Test.foo(getInv()) + id(get()) + select(get(), get()) + select(Test.foo(get()), Test.foo(get())) + select(Test.foo(get()), get()) + select(getInv(), getInv()) + select(Test.foo(getInv()), Test.foo(getInv())) + select(Test.foo(getInv()), getInv()) + select(getInv(), Test.foo(getInv())) + select(id(get()), id(get())) + build2 { + emit(1) + select(this@build.get(), get()) + select(Test.foo(this@build.get()), Test.foo(get())) + select(this@build.getInv(), getInv()) + select(Test.foo(this@build.getInv()), Test.foo(getInv())) + select(Test.foo(this@build.getInv()), getInv()) + select(id(this@build.get()), id(get())) + "" + } + "" + } + + return "OK" +} diff --git a/compiler/testData/codegen/box/inference/builderInference/commonSuperTypeContravariant.kt b/compiler/testData/codegen/box/inference/builderInference/commonSuperTypeContravariant.kt new file mode 100644 index 00000000000..d57bf59afeb --- /dev/null +++ b/compiler/testData/codegen/box/inference/builderInference/commonSuperTypeContravariant.kt @@ -0,0 +1,62 @@ +// !LANGUAGE: +UnrestrictedBuilderInference +// WITH_RUNTIME + +// FILE: Test.java + +class Test { + static T foo(T x) { return x; } +} + +// FILE: main.kt +import kotlin.experimental.ExperimentalTypeInference + +@UseExperimental(ExperimentalTypeInference::class) +fun build(@BuilderInference block: TestInterface.() -> Unit) {} + +@UseExperimental(ExperimentalTypeInference::class) +fun build2(@BuilderInference block: TestInterface.() -> Unit) {} + +class In + +interface TestInterface { + fun emit(r: R) + fun get(): R + fun getIn(): In +} + +fun id(x: U): U? = x +fun select1(x: E, y: In): E? = x +fun select2(x: E, y: In): E = x +fun select3(x: E?, y: In): E = x!! +fun select4(x: E?, y: In): E = x!! + +fun box(): String { + val ret = build { + emit("1") + select1(get(), getIn()) + select1(get(), Test.foo(getIn())) + select1(Test.foo(get()), Test.foo(getIn())) + select1(Test.foo(get()), getIn()) + select4(get(), getIn()) + select4(get(), Test.foo(getIn())) + select4(Test.foo(get()), Test.foo(getIn())) + select4(Test.foo(get()), getIn()) + + select4(id(Test.foo(get())), getIn()) + "" + } + val ret2 = build { + emit(if (true) "" else null) + select2(get(), getIn()) + select2(get(), Test.foo(getIn())) + select2(Test.foo(get()), Test.foo(getIn())) + select2(Test.foo(get()), getIn()) + select3(get(), getIn()) + select3(get(), Test.foo(getIn())) + select3(Test.foo(get()), Test.foo(getIn())) + select3(Test.foo(get()), getIn()) + "" + } + + return "OK" +} diff --git a/compiler/testData/codegen/box/inference/builderInference/commonSuperTypeCovariant.kt b/compiler/testData/codegen/box/inference/builderInference/commonSuperTypeCovariant.kt new file mode 100644 index 00000000000..8759fc0446a --- /dev/null +++ b/compiler/testData/codegen/box/inference/builderInference/commonSuperTypeCovariant.kt @@ -0,0 +1,82 @@ +// !LANGUAGE: +UnrestrictedBuilderInference +// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE +// WITH_RUNTIME + +// FILE: Test.java + +class Test { + static T foo(T x) { return x; } +} + +// FILE: main.kt +import kotlin.experimental.ExperimentalTypeInference + +@UseExperimental(ExperimentalTypeInference::class) +fun build(@BuilderInference block: TestInterface.() -> Unit) {} + +@UseExperimental(ExperimentalTypeInference::class) +fun build2(@BuilderInference block: TestInterface.() -> Unit) {} + +class Out + +interface TestInterface { + fun emit(r: R) + fun get(): R + fun getOut(): Out +} + +fun id(x: U): U? = x +fun select1(x: E, y: Out): E? = x +fun select2(x: E, y: Out): E = x +fun select3(x: E?, y: Out): E = x!! +fun select4(x: E?, y: Out): E = x!! + +fun box(): String { + val ret = build { + emit("1") + select1(get(), getOut()) + select1(get(), Test.foo(getOut())) + select1(Test.foo(get()), Test.foo(getOut())) + select1(Test.foo(get()), getOut()) + select2(get(), getOut()) + select2(get(), Test.foo(getOut())) + select2(Test.foo(get()), Test.foo(getOut())) + select2(Test.foo(get()), getOut()) + select3(get(), getOut()) + select3(get(), Test.foo(getOut())) + select3(Test.foo(get()), Test.foo(getOut())) + select3(Test.foo(get()), getOut()) + select4(get(), getOut()) + select4(get(), Test.foo(getOut())) + select4(Test.foo(get()), Test.foo(getOut())) + select4(Test.foo(get()), getOut()) + + select4(id(Test.foo(get())), getOut()) + + build2 { + emit(1) + select1(this@build.get(), getOut()) + select1(get(), Test.foo(this@build.getOut())) + select1(Test.foo(this@build.get()), Test.foo(getOut())) + select1(Test.foo(get()), this@build.getOut()) + select2(this@build.get(), getOut()) + select2(get(), Test.foo(this@build.getOut())) + select2(Test.foo(this@build.get()), Test.foo(getOut())) + select2(Test.foo(get()), this@build.getOut()) + select3(this@build.get(), getOut()) + select3(get(), Test.foo(this@build.getOut())) + select3(Test.foo(this@build.get()), Test.foo(getOut())) + select3(Test.foo(get()), this@build.getOut()) + select4(this@build.get(), getOut()) + select4(get(), Test.foo(this@build.getOut())) + select4(Test.foo(this@build.get()), Test.foo(getOut())) + select4(Test.foo(get()), this@build.getOut()) + + select4(id(Test.foo(this@build.get())), getOut()) + "" + } + "" + } + + return "OK" +} diff --git a/compiler/testData/codegen/box/inference/builderInference/commonSuperTypeInvariant.kt b/compiler/testData/codegen/box/inference/builderInference/commonSuperTypeInvariant.kt new file mode 100644 index 00000000000..4e5f14c6d56 --- /dev/null +++ b/compiler/testData/codegen/box/inference/builderInference/commonSuperTypeInvariant.kt @@ -0,0 +1,64 @@ +// !LANGUAGE: +UnrestrictedBuilderInference +// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE +// WITH_RUNTIME + +// FILE: Test.java + +class Test { + static T foo(T x) { return x; } +} + +// FILE: main.kt +import kotlin.experimental.ExperimentalTypeInference + +@UseExperimental(ExperimentalTypeInference::class) +fun build(@BuilderInference block: TestInterface.() -> Unit) {} + +@UseExperimental(ExperimentalTypeInference::class) +fun build2(@BuilderInference block: TestInterface.() -> Unit) {} + +class Inv + +interface TestInterface { + fun emit(r: R) + fun get(): R + fun getInv(): Inv +} + +fun id(x: U): U? = x +fun select1(x: E, y: Inv): E? = x +fun select2(x: E, y: Inv): E = x +fun select3(x: E?, y: Inv): E = x!! +fun select4(x: E?, y: Inv): E = x!! + +fun box(): String { + val ret1 = build { + emit("1") + select1(get(), getInv()) + select1(get(), Test.foo(getInv())) + select1(Test.foo(get()), Test.foo(getInv())) + select1(Test.foo(get()), getInv()) + select4(get(), getInv()) + select4(get(), Test.foo(getInv())) + select4(Test.foo(get()), Test.foo(getInv())) + select4(Test.foo(get()), getInv()) + + select4(id(Test.foo(get())), getInv()) + "" + } + + val ret2 = build { + emit(if (true) "1" else null) + select2(get(), getInv()) + select2(get(), Test.foo(getInv())) + select2(Test.foo(get()), Test.foo(getInv())) + select2(Test.foo(get()), getInv()) + select3(get(), getInv()) + select3(get(), Test.foo(getInv())) + select3(Test.foo(get()), Test.foo(getInv())) + select3(Test.foo(get()), getInv()) + "" + } + + return "OK" +} diff --git a/compiler/testData/codegen/box/inference/builderInference/commonSuperTypeNullable.kt b/compiler/testData/codegen/box/inference/builderInference/commonSuperTypeNullable.kt new file mode 100644 index 00000000000..000f2160650 --- /dev/null +++ b/compiler/testData/codegen/box/inference/builderInference/commonSuperTypeNullable.kt @@ -0,0 +1,83 @@ +// !LANGUAGE: +UnrestrictedBuilderInference +// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE +// WITH_RUNTIME + +// FILE: Test.java + +import org.jetbrains.annotations.*; + +class Test { + @Nullable + static T foo(T x) { return x; } +} + +// FILE: main.kt +import kotlin.experimental.ExperimentalTypeInference + +@UseExperimental(ExperimentalTypeInference::class) +fun build(@BuilderInference block: TestInterface.() -> Unit) {} + +@UseExperimental(ExperimentalTypeInference::class) +fun build2(@BuilderInference block: TestInterface.() -> Unit) {} + +class Inv + +interface TestInterface { + fun emit(r: R) + fun get(): R + fun getInv(): Inv +} + +fun id(x: U): U? = x +fun select(vararg x: E): E? = x[0] + +fun box(): String { + val ret = build { + emit("1") + Test.foo(get()) + Test.foo(getInv()) + id(get()) + select(get(), get()) + select(Test.foo(get()), Test.foo(get())) + select(Test.foo(get()), get()) + select(getInv(), getInv()) + select(Test.foo(getInv()), Test.foo(getInv())) + select(Test.foo(getInv()), getInv()) + select(getInv(), Test.foo(getInv())) + select(id(get()), id(get())) + build2 { + emit(1) + select(this@build.get(), get()) + select(Test.foo(this@build.get()), Test.foo(get())) + select(this@build.getInv(), getInv()) + select(Test.foo(this@build.getInv()), Test.foo(getInv())) + select(Test.foo(this@build.getInv()), getInv()) + select(id(this@build.get()), id(get())) + "" + } + "" + } + val ret2 = build { + emit("1") + select(get(), null) + select(Test.foo(null), Test.foo(get())) + select(Test.foo(get()), null) + select(null, getInv()) + select(Test.foo(getInv()), Test.foo(null)) + select(Test.foo(null), getInv()) + select(getInv(), Test.foo(null)) + select(id(null), id(get())) + build2 { + emit(1) + select(this@build.get(), get(), null) + select(Test.foo(this@build.get()), Test.foo(get()), null) + select(this@build.getInv(), getInv(), null) + select(Test.foo(this@build.getInv()), Test.foo(getInv()), null) + select(Test.foo(this@build.getInv()), getInv(), null) + select(id(this@build.get()), id(get()), null) + "" + } + "" + } + return "OK" +} diff --git a/compiler/testData/codegen/box/inference/builderInference/intersect.kt b/compiler/testData/codegen/box/inference/builderInference/intersect.kt new file mode 100644 index 00000000000..71249aa8613 --- /dev/null +++ b/compiler/testData/codegen/box/inference/builderInference/intersect.kt @@ -0,0 +1,49 @@ +// !LANGUAGE: +UnrestrictedBuilderInference +// WITH_RUNTIME + +// FILE: Test.java + +class Test { + static T foo(T x) { return x; } +} + +// FILE: main.kt +import kotlin.experimental.ExperimentalTypeInference + +@UseExperimental(ExperimentalTypeInference::class) +fun build(@BuilderInference block: TestInterface.() -> Unit) {} + +@UseExperimental(ExperimentalTypeInference::class) +fun build2(@BuilderInference block: TestInterface.() -> Unit) {} + +class In + +interface TestInterface { + fun emit(r: R) + fun get(): R + fun getIn(): In +} + +fun id(x: U) = x +fun intersect(vararg x: In): E = null as E + +fun box(): String { + val ret = build { + emit("1") + intersect(getIn(), getIn()) + intersect(getIn(), Test.foo(getIn())) + intersect(Test.foo(getIn()), Test.foo(getIn())) + intersect(Test.foo(getIn()), getIn()) + + build2 { + emit(1) + intersect(this@build.getIn(), getIn()) + intersect(getIn(), Test.foo(this@build.getIn())) + intersect(Test.foo(this@build.getIn()), Test.foo(getIn())) + intersect(Test.foo(getIn()), this@build.getIn()) + "" + } + "" + } + return "OK" +} diff --git a/compiler/testData/codegen/box/inference/builderInference/labaledCall.kt b/compiler/testData/codegen/box/inference/builderInference/labaledCall.kt new file mode 100644 index 00000000000..62f2664e5f3 --- /dev/null +++ b/compiler/testData/codegen/box/inference/builderInference/labaledCall.kt @@ -0,0 +1,23 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -UNCHECKED_CAST -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE +// WITH_RUNTIME + +// FILE: main.kt +import kotlin.experimental.ExperimentalTypeInference + +@UseExperimental(ExperimentalTypeInference::class) +fun build(@BuilderInference block: TestInterface.() -> Unit) {} + +interface TestInterface { + fun emit(r: R) + fun get(): R +} + +fun box(): String { + build myLabel@ { + emit("") + val x = this@myLabel + "" + } + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/inference/builderInference/memberScope.kt b/compiler/testData/codegen/box/inference/builderInference/memberScope.kt new file mode 100644 index 00000000000..c79e6c01900 --- /dev/null +++ b/compiler/testData/codegen/box/inference/builderInference/memberScope.kt @@ -0,0 +1,72 @@ +// !LANGUAGE: +UnrestrictedBuilderInference +// !DIAGNOSTICS: -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED +// WITH_RUNTIME + +// FILE: main.kt +import kotlin.experimental.ExperimentalTypeInference + +interface TestInterface { + fun emit(r: R) + fun get(): R +} + +@UseExperimental(ExperimentalTypeInference::class) +fun build(@BuilderInference block: TestInterface.() -> Unit) {} + +fun Any.test() {} +fun Any?.test2() {} + +fun box(): String { + val ret = build { + emit(1) + emit(null) + get()?.test() + get()?.test2() + get().test2() + get()?.hashCode() + get()?.equals(1) + val x = get() + x?.hashCode() + x?.equals(1) + + if (get() == null) {} + if (get() === null) {} + + if (x != null) { + x?.hashCode() + x?.equals(1) + x.equals("") + x.hashCode() + x.toString() + x.test() + x?.test2() + x.test2() + } + + if (x == null) { + x?.hashCode() + x?.equals(1) + // x.equals("") // it'd be an error, because here we try to add constraint `Nothing? < Any` +// x.hashCode() +// x.toString() +// x.test() + x?.test2() + x.test2() + } + + if (x === null) { + x?.hashCode() + x?.equals(1) + // x.equals("") // it'd be an error, because here we try to add constraint `Nothing? < Any` +// x.hashCode() +// x.toString() +// x.test() + x?.test2() + x.test2() + } + + "" + } + + return "OK" +} diff --git a/compiler/testData/codegen/box/inference/builderInference/nullability.kt b/compiler/testData/codegen/box/inference/builderInference/nullability.kt new file mode 100644 index 00000000000..f746939d9ca --- /dev/null +++ b/compiler/testData/codegen/box/inference/builderInference/nullability.kt @@ -0,0 +1,67 @@ +// !LANGUAGE: +UnrestrictedBuilderInference +// !DIAGNOSTICS: -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED +// WITH_RUNTIME + +// FILE: main.kt +import kotlin.experimental.ExperimentalTypeInference + +interface TestInterface { + fun emit(r: R) + fun get(): R +} + +@UseExperimental(ExperimentalTypeInference::class) +fun build(@BuilderInference block: TestInterface.() -> Unit) {} + +@UseExperimental(ExperimentalTypeInference::class) +fun build2(@BuilderInference block: TestInterface.() -> Unit) {} + +@UseExperimental(ExperimentalTypeInference::class) +fun build3(@BuilderInference block: TestInterface.() -> Unit) {} + +@UseExperimental(ExperimentalTypeInference::class) +fun build4(x: R2, @BuilderInference block: TestInterface.() -> Unit) {} + +fun test(a: String?) { + val ret1 = build { + emit(1) + get()?.equals("") + val x = get() + x?.equals("") + x ?: 1 + x!! + "" + } + val ret2 = build2 { + emit(1) + get()?.equals("") + val x = get() + x?.equals("") + x ?: 1 + x!! + "" + } + val ret3 = build3 { + emit(1) + get()?.equals("") + val x = get() + x?.equals("") + x ?: 1 + x!! + "" + } + val ret4 = build4(1) { + emit(1) + get()?.equals("") + val x = get() + x?.equals("") + x ?: 1 + x!! + "" + } +} + +fun box(): String { + test("") + return "OK" +} diff --git a/compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExression.kt b/compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExression.kt new file mode 100644 index 00000000000..419edc67b68 --- /dev/null +++ b/compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExression.kt @@ -0,0 +1,171 @@ +// !LANGUAGE: +UnrestrictedBuilderInference +// WITH_RUNTIME +// SKIP_TXT + +import kotlin.experimental.ExperimentalTypeInference + +fun FlowCollector.bar(): K = null as K +fun FlowCollector.foo(): K = null as K + +fun K.bar3(): K = null as K +fun K.foo3(): K = null as K + +fun bar2(): Int = 1 +fun foo2(): Float = 1f + +val bar4: Int + get() = 1 + +var foo4: Float + get() = 1f + set(value) {} + +val FlowCollector.bar5: K get() = null as K +val FlowCollector.foo5: K get() = null as K + +class Foo6 + +class Foo7 +fun foo7() = null as Foo7 + +interface FlowCollector {} + +@OptIn(ExperimentalTypeInference::class) +fun flow(@BuilderInference block: suspend FlowCollector.() -> Unit) = Flow(block) + +class Flow(private val block: suspend FlowCollector.() -> Unit) + +fun poll1(flag: Boolean): Flow { + return flow { + val inv = if (flag) { ::bar2 } else { ::foo2 } + inv() + } +} + +fun poll11(flag: Boolean): Flow { + return flow { + val inv = if (flag) { ::bar2 } else { ::foo2 } + inv() + } +} + +fun poll12(flag: Boolean): Flow { + return flow { + val inv = if (flag) { ::bar3 } else { ::foo3 } + inv() + } +} + +fun poll13(flag: Boolean): Flow { + return flow { + val inv = if (flag) { ::bar2 } else { ::foo3 } + inv() + } +} + +fun poll14(flag: Boolean): Flow { + return flow { + val inv = if (flag) { ::bar4 } else { ::foo4 } + inv() + } +} + +fun poll15(flag: Boolean): Flow { + return flow { + val inv = if (flag) { ::bar5 } else { ::foo5 } + inv() + } +} + +fun poll16(flag: Boolean): Flow { + return flow { + val inv = if (flag) { ::Foo6 } else { ::Foo6 } + inv() + } +} + +fun poll4(): Flow { + return flow { + val inv = try { ::bar } finally { ::foo } + inv() + } +} + +fun poll41(): Flow { + return flow { + val inv = try { ::bar2 } finally { ::foo2 } + inv() + } +} + +fun poll42(): Flow { + return flow { + val inv = try { ::bar3 } finally { ::foo3 } + inv() + } +} + +fun poll43(): Flow { + return flow { + val inv = try { ::bar4 } finally { ::foo4 } + inv() + } +} + +fun poll44(): Flow { + return flow { + val inv = try { ::bar5 } finally { ::foo5 } + inv() + } +} + +fun poll45(): Flow { + return flow { + val inv = try { ::Foo6 } finally { ::Foo6 } + inv() + } +} + +fun poll5(): Flow { + return flow { + val inv = try { ::bar } catch (e: Exception) { ::foo } finally { ::foo } + inv() + } +} + +fun poll51(): Flow { + return flow { + val inv = try { ::bar2 } catch (e: Exception) { ::foo2 } finally { ::foo2 } + inv() + } +} + +fun poll52(): Flow { + return flow { + val inv = try { ::bar3 } catch (e: Exception) { ::foo3 } finally { ::foo3 } + inv() + } +} + +fun poll53(): Flow { + return flow { + val inv = try { ::bar4 } catch (e: Exception) { ::foo4 } finally { ::foo4 } + inv() + } +} + +fun poll54(): Flow { + return flow { + val inv = try { ::bar5 } catch (e: Exception) { ::foo5 } finally { ::foo5 } + inv() + } +} + +fun poll55(): Flow { + return flow { + val inv = try { ::Foo6 } catch (e: Exception) { ::Foo6 } finally { ::Foo6 } + inv() + } +} + +fun box() = "OK" \ No newline at end of file diff --git a/compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontRewriteAtSlice.kt b/compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontRewriteAtSlice.kt new file mode 100644 index 00000000000..68504986750 --- /dev/null +++ b/compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontRewriteAtSlice.kt @@ -0,0 +1,66 @@ +// WITH_RUNTIME +// SKIP_TXT +// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION + +import kotlin.experimental.ExperimentalTypeInference + +fun FlowCollector.bar(): K = null as K +fun FlowCollector.foo(): K = null as K + +fun K.bar3(): K = null as K +fun K.foo3(): K = null as K + +fun bar2(): Int = 1 +fun foo2(): Float = 1f + +val bar4: Int + get() = 1 + +var foo4: Float + get() = 1f + set(value) {} + +val FlowCollector.bar5: K get() = null as K +val FlowCollector.foo5: K get() = null as K + +class Foo6 + +class Foo7 +fun foo7() = null as Foo7 + +interface FlowCollector {} + +@OptIn(ExperimentalTypeInference::class) +fun flow(@BuilderInference block: suspend FlowCollector.() -> Unit) = Flow(block) + +class Flow(private val block: suspend FlowCollector.() -> Unit) + +fun poll71(): Flow { + return flow { + val inv = ::bar2!! + inv() + } +} + +fun poll73(): Flow { + return flow { + val inv = ::bar4!! + inv + } +} + +fun poll75(): Flow { + return flow { + val inv = ::Foo6!! + inv + } +} + +fun poll85(): Flow { + return flow { + val inv = ::Foo6 in setOf(::Foo6) + inv + } +} + +fun box() = "OK" diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/constraints/withExpectedType.kt b/compiler/testData/codegen/box/inference/builderInference/withExpectedType.kt similarity index 75% rename from compiler/testData/diagnostics/tests/inference/builderInference/constraints/withExpectedType.kt rename to compiler/testData/codegen/box/inference/builderInference/withExpectedType.kt index 5df09031f2c..8014c2d9cdd 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/constraints/withExpectedType.kt +++ b/compiler/testData/codegen/box/inference/builderInference/withExpectedType.kt @@ -2,24 +2,33 @@ // WITH_RUNTIME // !DIAGNOSTICS: -EXPERIMENTAL_API_USAGE_ERROR -CAST_NEVER_SUCCEEDS +import kotlin.experimental.ExperimentalTypeInference + fun id(x: K): K = x +@UseExperimental(ExperimentalTypeInference::class) fun build(@BuilderInference builderAction: MutableMap.() -> V) {} +@UseExperimental(ExperimentalTypeInference::class) fun build2(@BuilderInference builderAction: MutableMap.() -> K) {} +@UseExperimental(ExperimentalTypeInference::class) fun build3(@BuilderInference builderAction: MutableMap.(K) -> Unit) {} +@UseExperimental(ExperimentalTypeInference::class) fun build4(@BuilderInference builderAction: MutableMap.() -> MutableMap) {} +@UseExperimental(ExperimentalTypeInference::class) fun build5(@BuilderInference builderAction: MutableMap.() -> MutableMap) {} +@UseExperimental(ExperimentalTypeInference::class) fun build6(@BuilderInference builderAction: MutableMap.() -> MutableMap) {} -fun build7(@BuilderInference builderAction: MutableMap.() -> MutableMap) = null as MutableMap +@UseExperimental(ExperimentalTypeInference::class) +fun build7(@BuilderInference builderAction: MutableMap.() -> MutableMap) = mutableMapOf() @ExperimentalStdlibApi -fun main() { +fun box(): String { buildList { add("") val x: MutableList = this@buildList @@ -62,6 +71,8 @@ fun main() { val x: MutableMap = build7 { id(run { this }) } + + return "OK" } fun MutableMap.foo() {} diff --git a/compiler/testData/diagnostics/tests/ResolveToJava.kt b/compiler/testData/diagnostics/tests/ResolveToJava.kt index 41451b3c014..8a0a8296ae3 100644 --- a/compiler/testData/diagnostics/tests/ResolveToJava.kt +++ b/compiler/testData/diagnostics/tests/ResolveToJava.kt @@ -21,7 +21,7 @@ fun test(l : java.util.List) { val f : java.io.File? = null - Collections.emptyList + Collections.emptyList Collections.emptyList Collections.emptyList() Collections.emptyList() diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/constraints/withExpectedType.fir.kt b/compiler/testData/diagnostics/tests/inference/builderInference/constraints/withExpectedType.fir.kt deleted file mode 100644 index d0a2d26f284..00000000000 --- a/compiler/testData/diagnostics/tests/inference/builderInference/constraints/withExpectedType.fir.kt +++ /dev/null @@ -1,69 +0,0 @@ -// !LANGUAGE: +UnrestrictedBuilderInference -// WITH_RUNTIME -// !DIAGNOSTICS: -EXPERIMENTAL_API_USAGE_ERROR -CAST_NEVER_SUCCEEDS - -fun id(x: K): K = x - -fun build(@BuilderInference builderAction: MutableMap.() -> V) {} - -fun build2(@BuilderInference builderAction: MutableMap.() -> K) {} - -fun build3(@BuilderInference builderAction: MutableMap.(K) -> Unit) {} - -fun build4(@BuilderInference builderAction: MutableMap.() -> MutableMap) {} - -fun build5(@BuilderInference builderAction: MutableMap.() -> MutableMap) {} - -fun build6(@BuilderInference builderAction: MutableMap.() -> MutableMap) {} - -fun build7(@BuilderInference builderAction: MutableMap.() -> MutableMap) = null as MutableMap - -@ExperimentalStdlibApi -fun main() { - buildList { - add("") - val x: MutableList = this@buildList - } - buildMap { - val x: Function2 = ::put - } - - build { - get("") - "" - } - - build2 { - val x: String = this.values.first() - 1 - } - - build2 { - take(this.values.first()) - 1 - } - - build3 { key: String -> - take(this.values.first()) - } - - build3 { this.foo() } - - build4 { this } - - build4 { this.run { this } } - - build4 { run { this } } - build4 { id(run { this }) } - - build5 { id(run { this }) } - build6 { id(run { this }) } - - val x: MutableMap = build7 { - id(run { this }) - } -} - -fun MutableMap.foo() {} - -fun take(x: String) {} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/constraints/withExpectedType.txt b/compiler/testData/diagnostics/tests/inference/builderInference/constraints/withExpectedType.txt deleted file mode 100644 index cdd02794752..00000000000 --- a/compiler/testData/diagnostics/tests/inference/builderInference/constraints/withExpectedType.txt +++ /dev/null @@ -1,14 +0,0 @@ -package - -public fun build(/*0*/ @kotlin.BuilderInference builderAction: kotlin.collections.MutableMap.() -> V): kotlin.Unit -public fun build2(/*0*/ @kotlin.BuilderInference builderAction: kotlin.collections.MutableMap.() -> K): kotlin.Unit -public fun build3(/*0*/ @kotlin.BuilderInference builderAction: kotlin.collections.MutableMap.(K) -> kotlin.Unit): kotlin.Unit -public fun build4(/*0*/ @kotlin.BuilderInference builderAction: kotlin.collections.MutableMap.() -> kotlin.collections.MutableMap): kotlin.Unit -public fun build5(/*0*/ @kotlin.BuilderInference builderAction: kotlin.collections.MutableMap.() -> kotlin.collections.MutableMap): kotlin.Unit -public fun build6(/*0*/ @kotlin.BuilderInference builderAction: kotlin.collections.MutableMap.() -> kotlin.collections.MutableMap): kotlin.Unit -public fun build7(/*0*/ @kotlin.BuilderInference builderAction: kotlin.collections.MutableMap.() -> kotlin.collections.MutableMap): kotlin.collections.MutableMap -public fun id(/*0*/ x: K): K -@kotlin.ExperimentalStdlibApi public fun main(): kotlin.Unit -public fun take(/*0*/ x: kotlin.String): kotlin.Unit -public fun kotlin.collections.MutableMap.foo(): kotlin.Unit - diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferences.kt b/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferences.kt index da4759bb918..f811f3aa86c 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferences.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferences.kt @@ -38,7 +38,7 @@ fun select(vararg x: R) = x[0] fun poll0(): Flow { return flow { - val inv = select(::bar, ::foo) + val inv = select(::bar, ::foo) inv() } } @@ -52,7 +52,7 @@ fun poll01(): Flow { fun poll02(): Flow { return flow { - val inv = select(::bar3, ::foo3) + val inv = select(::bar3, ::foo3) inv() } } @@ -66,7 +66,7 @@ fun poll03(): Flow { fun poll04(): Flow { return flow { - val inv = select(::bar5, ::foo5) + val inv = select(::bar5, ::foo5) inv } } @@ -143,7 +143,7 @@ fun poll17(flag: Boolean): Flow { fun poll2(flag: Boolean): Flow { return flow { - val inv = when (flag) { true -> ::bar else -> ::foo } + val inv = when (flag) { true -> ::bar else -> ::foo } inv() } } @@ -157,7 +157,7 @@ fun poll21(flag: Boolean): Flow { fun poll22(flag: Boolean): Flow { return flow { - val inv = when (flag) { true -> ::bar3 else -> ::foo3 } + val inv = when (flag) { true -> ::bar3 else -> ::foo3 } inv() } } @@ -171,7 +171,7 @@ fun poll23(flag: Boolean): Flow { fun poll24(flag: Boolean): Flow { return flow { - val inv = when (flag) { true -> ::bar5 else -> ::foo5 } + val inv = when (flag) { true -> ::bar5 else -> ::foo5 } inv } } @@ -192,7 +192,7 @@ fun poll26(flag: Boolean): Flow { fun poll3(flag: Boolean): Flow { return flow { - val inv = when (flag) { true -> ::bar false -> ::foo } + val inv = when (flag) { true -> ::bar false -> ::foo } inv() } } @@ -206,7 +206,7 @@ fun poll31(flag: Boolean): Flow { fun poll32(flag: Boolean): Flow { return flow { - val inv = when (flag) { true -> ::bar3 false -> ::foo3 } + val inv = when (flag) { true -> ::bar3 false -> ::foo3 } inv() } } @@ -220,7 +220,7 @@ fun poll33(flag: Boolean): Flow { fun poll34(flag: Boolean): Flow { return flow { - val inv = when (flag) { true -> ::bar5 false -> ::foo5 } + val inv = when (flag) { true -> ::bar5 false -> ::foo5 } inv } } diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorTypeUnrestricted.fir.kt b/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorTypeUnrestricted.fir.kt new file mode 100644 index 00000000000..fdf85f02978 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorTypeUnrestricted.fir.kt @@ -0,0 +1,87 @@ +// !LANGUAGE: +UnrestrictedBuilderInference +// WITH_RUNTIME +// SKIP_TXT +// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION + +import kotlin.experimental.ExperimentalTypeInference + +fun FlowCollector.bar(): K = null as K +fun FlowCollector.foo(): K = null as K + +fun K.bar3(): K = null as K +fun K.foo3(): K = null as K + +fun bar2(): Int = 1 +fun foo2(): Float = 1f + +val bar4: Int + get() = 1 + +var foo4: Float + get() = 1f + set(value) {} + +val FlowCollector.bar5: K get() = null as K +val FlowCollector.foo5: K get() = null as K + +class Foo6 + +class Foo7 +fun foo7() = null as Foo7 + +interface FlowCollector {} + +fun flow(@BuilderInference block: suspend FlowCollector.() -> Unit) = Flow(block) + +class Flow(private val block: suspend FlowCollector.() -> Unit) + + +fun poll7(): Flow { + return flow { + val inv = ::bar!! + inv() + } +} + +fun poll71(): Flow { + return flow { + val inv = ::bar2!! + inv() + } +} + +fun poll72(): Flow { + return flow { + val inv = ::bar3!! + inv() + } +} + +fun poll73(): Flow { + return flow { + val inv = ::bar4!! + inv + } +} + +fun poll74(): Flow { + return flow { + val inv = ::bar5!! + inv + } +} + +fun poll75(): Flow { + return flow { + val inv = ::Foo6!! + inv + } +} + +fun poll76(): Flow { + return flow { + val inv = ::Foo7!! + inv + } +} + diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorTypeUnrestricted.kt b/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorTypeUnrestricted.kt new file mode 100644 index 00000000000..03b6309b73c --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorTypeUnrestricted.kt @@ -0,0 +1,87 @@ +// !LANGUAGE: +UnrestrictedBuilderInference +// WITH_RUNTIME +// SKIP_TXT +// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION + +import kotlin.experimental.ExperimentalTypeInference + +fun FlowCollector.bar(): K = null as K +fun FlowCollector.foo(): K = null as K + +fun K.bar3(): K = null as K +fun K.foo3(): K = null as K + +fun bar2(): Int = 1 +fun foo2(): Float = 1f + +val bar4: Int + get() = 1 + +var foo4: Float + get() = 1f + set(value) {} + +val FlowCollector.bar5: K get() = null as K +val FlowCollector.foo5: K get() = null as K + +class Foo6 + +class Foo7 +fun foo7() = null as Foo7 + +interface FlowCollector {} + +fun flow(@BuilderInference block: suspend FlowCollector.() -> Unit) = Flow(block) + +class Flow(private val block: suspend FlowCollector.() -> Unit) + + +fun poll7(): Flow { + return flow { + val inv = ::bar!! + inv() + } +} + +fun poll71(): Flow { + return flow { + val inv = ::bar2!! + inv() + } +} + +fun poll72(): Flow { + return flow { + val inv = ::bar3!! + inv() + } +} + +fun poll73(): Flow { + return flow { + val inv = ::bar4!! + inv + } +} + +fun poll74(): Flow { + return flow { + val inv = ::bar5!! + inv + } +} + +fun poll75(): Flow { + return flow { + val inv = ::Foo6!! + inv + } +} + +fun poll76(): Flow { + return flow { + val inv = ::Foo7!! + inv + } +} + diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesUnrestricted.fir.kt b/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesUnrestricted.fir.kt new file mode 100644 index 00000000000..2ee2e8f4e6e --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesUnrestricted.fir.kt @@ -0,0 +1,500 @@ +// !LANGUAGE: +UnrestrictedBuilderInference +// WITH_RUNTIME +// SKIP_TXT +// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION + +import kotlin.experimental.ExperimentalTypeInference + +fun FlowCollector.bar(): K = null as K +fun FlowCollector.foo(): K = null as K + +fun K.bar3(): K = null as K +fun K.foo3(): K = null as K + +fun bar2(): Int = 1 +fun foo2(): Float = 1f + +val bar4: Int + get() = 1 + +var foo4: Float + get() = 1f + set(value) {} + +val FlowCollector.bar5: K get() = null as K +val FlowCollector.foo5: K get() = null as K + +class Foo6 + +class Foo7 +fun foo7() = null as Foo7 + +interface FlowCollector {} + +fun flow(@BuilderInference block: suspend FlowCollector.() -> Unit): Flow = Flow(block) + +class Flow(private val block: suspend FlowCollector.() -> Unit) + +fun select(vararg x: R) = x[0] + +fun poll0(): Flow { + return flow { + val inv = select(::bar, ::foo) + inv() + } +} + +fun poll01(): Flow { + return flow { + val inv = select(::bar2, ::foo2) + inv() + } +} + +fun poll02(): Flow { + return flow { + val inv = select(::bar3, ::foo3) + inv() + } +} + +fun poll03(): Flow { + return flow { + val inv = select(::bar4, ::foo4) + inv() + } +} + +fun poll04(): Flow { + return flow { + val inv = select(::bar5, ::foo5) + inv + } +} + +fun poll05(): Flow { + return flow { + val inv = select(::Foo6, ::Foo6) + inv + } +} + +fun poll06(): Flow { + return flow { + val inv = select(foo7(), ::Foo7) + inv + } +} + +fun poll1(flag: Boolean): Flow { + return flow { + val inv = if (flag) { ::bar2 } else { ::foo2 } + inv() + } +} + +fun poll11(flag: Boolean): Flow { + return flow { + val inv = if (flag) { ::bar2 } else { ::foo2 } + inv() + } +} + +fun poll12(flag: Boolean): Flow { + return flow { + val inv = if (flag) { ::bar3 } else { ::foo3 } + inv() + } +} + +fun poll13(flag: Boolean): Flow { + return flow { + val inv = if (flag) { ::bar2 } else { ::foo3 } + inv() + } +} + +fun poll14(flag: Boolean): Flow { + return flow { + val inv = if (flag) { ::bar4 } else { ::foo4 } + inv() + } +} + +fun poll15(flag: Boolean): Flow { + return flow { + val inv = if (flag) { ::bar5 } else { ::foo5 } + inv() + } +} + +fun poll16(flag: Boolean): Flow { + return flow { + val inv = if (flag) { ::Foo6 } else { ::Foo6 } + inv() + } +} + +fun poll17(flag: Boolean): Flow { + return flow { + val inv = if (flag) { foo7() } else { ::Foo7 } + inv + } +} + +fun poll2(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::bar else -> ::foo } + inv() + } +} + +fun poll21(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::bar2 else -> ::foo2 } + inv() + } +} + +fun poll22(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::bar3 else -> ::foo3 } + inv() + } +} + +fun poll23(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::bar4 else -> ::foo4 } + inv() + } +} + +fun poll24(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::bar5 else -> ::foo5 } + inv + } +} + +fun poll25(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::Foo6 else -> ::Foo6 } + inv + } +} + +fun poll26(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::Foo7 false -> foo7() else -> ::Foo7 } + inv + } +} + +fun poll3(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::bar false -> ::foo } + inv() + } +} + +fun poll31(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::bar2 false -> ::foo2 } + inv() + } +} + +fun poll32(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::bar3 false -> ::foo3 } + inv() + } +} + +fun poll33(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::bar4 false -> ::foo4 } + inv() + } +} + +fun poll34(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::bar5 false -> ::foo5 } + inv + } +} + +fun poll35(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::Foo6 false -> ::Foo6 } + inv + } +} + +fun poll36(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::Foo7 false -> foo7() } + inv + } +} + +fun poll4(): Flow { + return flow { + val inv = try { ::bar } finally { ::foo } + inv() + } +} + +fun poll41(): Flow { + return flow { + val inv = try { ::bar2 } finally { ::foo2 } + inv() + } +} + +fun poll42(): Flow { + return flow { + val inv = try { ::bar3 } finally { ::foo3 } + inv() + } +} + +fun poll43(): Flow { + return flow { + val inv = try { ::bar4 } finally { ::foo4 } + inv() + } +} + +fun poll44(): Flow { + return flow { + val inv = try { ::bar5 } finally { ::foo5 } + inv() + } +} + +fun poll45(): Flow { + return flow { + val inv = try { ::Foo6 } finally { ::Foo6 } + inv() + } +} + +fun poll46(): Flow { + return flow { + val inv = try { foo7() } finally { ::Foo7 } + inv + } +} + +fun poll5(): Flow { + return flow { + val inv = try { ::bar } catch (e: Exception) { ::foo } finally { ::foo } + inv() + } +} + +fun poll51(): Flow { + return flow { + val inv = try { ::bar2 } catch (e: Exception) { ::foo2 } finally { ::foo2 } + inv() + } +} + +fun poll52(): Flow { + return flow { + val inv = try { ::bar3 } catch (e: Exception) { ::foo3 } finally { ::foo3 } + inv() + } +} + +fun poll53(): Flow { + return flow { + val inv = try { ::bar4 } catch (e: Exception) { ::foo4 } finally { ::foo4 } + inv() + } +} + +fun poll54(): Flow { + return flow { + val inv = try { ::bar5 } catch (e: Exception) { ::foo5 } finally { ::foo5 } + inv() + } +} + +fun poll55(): Flow { + return flow { + val inv = try { ::Foo6 } catch (e: Exception) { ::Foo6 } finally { ::Foo6 } + inv() + } +} + +fun poll56(): Flow { + return flow { + val inv = try { ::Foo7 } catch (e: Exception) { foo7() } finally { foo7() } + inv + } +} + +fun poll6(): Flow { + return flow { + val inv = ::bar + inv + } +} + +fun poll61(): Flow { + return flow { + val inv = ::bar2 + inv + } +} + +fun poll62(): Flow { + return flow { + val inv = ::bar3 + inv + } +} + +fun poll63(): Flow { + return flow { + val inv = ::bar4 + inv + } +} + +fun poll64(): Flow { + return flow { + val inv = ::bar5 + inv + } +} + +fun poll65(): Flow { + return flow { + val inv = ::Foo6 + inv + } +} + +fun poll66(): Flow { + return flow { + val inv = ::Foo7 + inv + } +} + +fun poll7(): Flow { + return flow { + val inv = ::bar!! + inv() + } +} + +fun poll71(): Flow { + return flow { + val inv = ::bar2!! + inv() + } +} + +fun poll72(): Flow { + return flow { + val inv = ::bar3!! + inv() + } +} + +fun poll73(): Flow { + return flow { + val inv = ::bar4!! + inv + } +} + +fun poll74(): Flow { + return flow { + val inv = ::bar5!! + inv + } +} + +fun poll75(): Flow { + return flow { + val inv = ::Foo6!! + inv + } +} + +fun poll76(): Flow { + return flow { + val inv = ::Foo7!! + inv + } +} + +fun poll8(): Flow { + return flow { + val inv = ::bar in setOf(::foo) + inv() + } +} + +fun poll81(): Flow { + return flow { + val inv = ::bar2 in setOf(::foo2) + inv() + } +} + +fun poll82(): Flow { + return flow { + val inv = ::bar3 in setOf(::foo3) + inv() + } +} + +fun poll83(): Flow { + return flow { + val inv = ::bar4 in setOf(::foo4) + inv + } +} + +fun poll84(): Flow { + return flow { + val inv = ::bar5 in setOf(::foo5) + inv + } +} + +fun poll85(): Flow { + return flow { + val inv = ::Foo6 in setOf(::Foo6) + inv + } +} + +fun poll86(): Flow { + return flow { + val inv = ::Foo7 in setOf(::Foo7) + inv + } +} + +fun poll87(): Flow { + return flow { + val inv = ::Foo7 in setOf(foo7()) + inv + } +} + +fun poll88(): Flow { + return flow { + val inv = foo7() in setOf(::Foo7) + inv + } +} diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesUnrestricted.kt b/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesUnrestricted.kt new file mode 100644 index 00000000000..9a966645ea2 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesUnrestricted.kt @@ -0,0 +1,500 @@ +// !LANGUAGE: +UnrestrictedBuilderInference +// WITH_RUNTIME +// SKIP_TXT +// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION + +import kotlin.experimental.ExperimentalTypeInference + +fun FlowCollector.bar(): K = null as K +fun FlowCollector.foo(): K = null as K + +fun K.bar3(): K = null as K +fun K.foo3(): K = null as K + +fun bar2(): Int = 1 +fun foo2(): Float = 1f + +val bar4: Int + get() = 1 + +var foo4: Float + get() = 1f + set(value) {} + +val FlowCollector.bar5: K get() = null as K +val FlowCollector.foo5: K get() = null as K + +class Foo6 + +class Foo7 +fun foo7() = null as Foo7 + +interface FlowCollector {} + +fun flow(@BuilderInference block: suspend FlowCollector.() -> Unit): Flow = Flow(block) + +class Flow(private val block: suspend FlowCollector.() -> Unit) + +fun select(vararg x: R) = x[0] + +fun poll0(): Flow { + return flow { + val inv = select(::bar, ::foo) + inv() + } +} + +fun poll01(): Flow { + return flow { + val inv = select(::bar2, ::foo2) + inv() + } +} + +fun poll02(): Flow { + return flow { + val inv = select(::bar3, ::foo3) + inv() + } +} + +fun poll03(): Flow { + return flow { + val inv = select(::bar4, ::foo4) + inv() + } +} + +fun poll04(): Flow { + return flow { + val inv = select(::bar5, ::foo5) + inv + } +} + +fun poll05(): Flow { + return flow { + val inv = select(::Foo6, ::Foo6) + inv + } +} + +fun poll06(): Flow { + return flow { + val inv = select(foo7(), ::Foo7) + inv + } +} + +fun poll1(flag: Boolean): Flow { + return flow { + val inv = if (flag) { ::bar2 } else { ::foo2 } + inv() + } +} + +fun poll11(flag: Boolean): Flow { + return flow { + val inv = if (flag) { ::bar2 } else { ::foo2 } + inv() + } +} + +fun poll12(flag: Boolean): Flow { + return flow { + val inv = if (flag) { ::bar3 } else { ::foo3 } + inv() + } +} + +fun poll13(flag: Boolean): Flow { + return flow { + val inv = if (flag) { ::bar2 } else { ::foo3 } + inv() + } +} + +fun poll14(flag: Boolean): Flow { + return flow { + val inv = if (flag) { ::bar4 } else { ::foo4 } + inv() + } +} + +fun poll15(flag: Boolean): Flow { + return flow { + val inv = if (flag) { ::bar5 } else { ::foo5 } + inv() + } +} + +fun poll16(flag: Boolean): Flow { + return flow { + val inv = if (flag) { ::Foo6 } else { ::Foo6 } + inv() + } +} + +fun poll17(flag: Boolean): Flow { + return flow { + val inv = if (flag) { foo7() } else { ::Foo7 } + inv + } +} + +fun poll2(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::bar else -> ::foo } + inv() + } +} + +fun poll21(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::bar2 else -> ::foo2 } + inv() + } +} + +fun poll22(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::bar3 else -> ::foo3 } + inv() + } +} + +fun poll23(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::bar4 else -> ::foo4 } + inv() + } +} + +fun poll24(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::bar5 else -> ::foo5 } + inv + } +} + +fun poll25(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::Foo6 else -> ::Foo6 } + inv + } +} + +fun poll26(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::Foo7 false -> foo7() else -> ::Foo7 } + inv + } +} + +fun poll3(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::bar false -> ::foo } + inv() + } +} + +fun poll31(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::bar2 false -> ::foo2 } + inv() + } +} + +fun poll32(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::bar3 false -> ::foo3 } + inv() + } +} + +fun poll33(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::bar4 false -> ::foo4 } + inv() + } +} + +fun poll34(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::bar5 false -> ::foo5 } + inv + } +} + +fun poll35(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::Foo6 false -> ::Foo6 } + inv + } +} + +fun poll36(flag: Boolean): Flow { + return flow { + val inv = when (flag) { true -> ::Foo7 false -> foo7() } + inv + } +} + +fun poll4(): Flow { + return flow { + val inv = try { ::bar } finally { ::foo } + inv() + } +} + +fun poll41(): Flow { + return flow { + val inv = try { ::bar2 } finally { ::foo2 } + inv() + } +} + +fun poll42(): Flow { + return flow { + val inv = try { ::bar3 } finally { ::foo3 } + inv() + } +} + +fun poll43(): Flow { + return flow { + val inv = try { ::bar4 } finally { ::foo4 } + inv() + } +} + +fun poll44(): Flow { + return flow { + val inv = try { ::bar5 } finally { ::foo5 } + inv() + } +} + +fun poll45(): Flow { + return flow { + val inv = try { ::Foo6 } finally { ::Foo6 } + inv() + } +} + +fun poll46(): Flow { + return flow { + val inv = try { foo7() } finally { ::Foo7 } + inv + } +} + +fun poll5(): Flow { + return flow { + val inv = try { ::bar } catch (e: Exception) { ::foo } finally { ::foo } + inv() + } +} + +fun poll51(): Flow { + return flow { + val inv = try { ::bar2 } catch (e: Exception) { ::foo2 } finally { ::foo2 } + inv() + } +} + +fun poll52(): Flow { + return flow { + val inv = try { ::bar3 } catch (e: Exception) { ::foo3 } finally { ::foo3 } + inv() + } +} + +fun poll53(): Flow { + return flow { + val inv = try { ::bar4 } catch (e: Exception) { ::foo4 } finally { ::foo4 } + inv() + } +} + +fun poll54(): Flow { + return flow { + val inv = try { ::bar5 } catch (e: Exception) { ::foo5 } finally { ::foo5 } + inv() + } +} + +fun poll55(): Flow { + return flow { + val inv = try { ::Foo6 } catch (e: Exception) { ::Foo6 } finally { ::Foo6 } + inv() + } +} + +fun poll56(): Flow { + return flow { + val inv = try { ::Foo7 } catch (e: Exception) { foo7() } finally { foo7() } + inv + } +} + +fun poll6(): Flow { + return flow { + val inv = ::bar + inv + } +} + +fun poll61(): Flow { + return flow { + val inv = ::bar2 + inv + } +} + +fun poll62(): Flow { + return flow { + val inv = ::bar3 + inv + } +} + +fun poll63(): Flow { + return flow { + val inv = ::bar4 + inv + } +} + +fun poll64(): Flow { + return flow { + val inv = ::bar5 + inv + } +} + +fun poll65(): Flow { + return flow { + val inv = ::Foo6 + inv + } +} + +fun poll66(): Flow { + return flow { + val inv = ::Foo7 + inv + } +} + +fun poll7(): Flow { + return flow { + val inv = ::bar!! + inv() + } +} + +fun poll71(): Flow { + return flow { + val inv = ::bar2!! + inv() + } +} + +fun poll72(): Flow { + return flow { + val inv = ::bar3!! + inv() + } +} + +fun poll73(): Flow { + return flow { + val inv = ::bar4!! + inv + } +} + +fun poll74(): Flow { + return flow { + val inv = ::bar5!! + inv + } +} + +fun poll75(): Flow { + return flow { + val inv = ::Foo6!! + inv + } +} + +fun poll76(): Flow { + return flow { + val inv = ::Foo7!! + inv + } +} + +fun poll8(): Flow { + return flow { + val inv = ::bar in setOf(::foo) + inv() + } +} + +fun poll81(): Flow { + return flow { + val inv = ::bar2 in setOf(::foo2) + inv() + } +} + +fun poll82(): Flow { + return flow { + val inv = ::bar3 in setOf(::foo3) + inv() + } +} + +fun poll83(): Flow { + return flow { + val inv = ::bar4 in setOf(::foo4) + inv + } +} + +fun poll84(): Flow { + return flow { + val inv = ::bar5 in setOf(::foo5) + inv + } +} + +fun poll85(): Flow { + return flow { + val inv = ::Foo6 in setOf(::Foo6) + inv + } +} + +fun poll86(): Flow { + return flow { + val inv = ::Foo7 in setOf(::Foo7) + inv + } +} + +fun poll87(): Flow { + return flow { + val inv = ::Foo7 in setOf(foo7()) + inv + } +} + +fun poll88(): Flow { + return flow { + val inv = foo7() in setOf(::Foo7) + inv + } +} diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/capturedTypes.kt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/capturedTypes.kt index 16013c8d0a9..209a231fe35 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/capturedTypes.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/capturedTypes.kt @@ -28,12 +28,12 @@ fun capture(x: Inv): K = null as K fun main() { build { emit("") - ")!>getInv() - captureOut(")!>getInv()) - captureIn(")!>getInv()) + ")!>getInv() + captureOut(")!>getInv()) + captureIn(")!>getInv()) // K is fixed into CapturedType(out NotFixed: TypeVariable(R)) - capture(")!>getOut()) + capture(")!>getOut()) "" } build { diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperType.kt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperType.kt index b78cbe07598..d9c86a44a8f 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperType.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperType.kt @@ -33,15 +33,15 @@ fun test() { emit("1") Test.foo(get()) ..Inv?)")!>Test.foo(getInv()) - id(get()) - select(get(), get()) - select(Test.foo(get()), Test.foo(get())) - select(Test.foo(get()), get()) - ")!>select(getInv(), getInv()) - ..Inv?)")!>select(Test.foo(getInv()), Test.foo(getInv())) - ..Inv?)")!>select(Test.foo(getInv()), getInv()) - ..Inv?)")!>select(getInv(), Test.foo(getInv())) - select(id(get()), id(get())) + id(get()) + select(get(), get()) + select(Test.foo(get()), Test.foo(get())) + select(Test.foo(get()), get()) + ")!>select(getInv(), getInv()) + ..Inv?)")!>select(Test.foo(getInv()), Test.foo(getInv())) + ..Inv?)")!>select(Test.foo(getInv()), getInv()) + ..Inv?)")!>select(getInv(), Test.foo(getInv())) + select(id(get()), id(get())) build2 { emit(1) select(this@build.get(), get()) diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeCovariant.kt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeCovariant.kt index c1080efe39c..29413894bcb 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeCovariant.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeCovariant.kt @@ -34,24 +34,24 @@ fun select4(x: E?, y: Out): E = x!! fun test() { val ret = build { emit("1") - select1(get(), getOut()) - select1(get(), Test.foo(getOut())) - select1(Test.foo(get()), Test.foo(getOut())) - select1(Test.foo(get()), getOut()) - select2(get(), getOut()) - select2(get(), Test.foo(getOut())) - select2(Test.foo(get()), Test.foo(getOut())) - select2(Test.foo(get()), getOut()) - select3(get(), getOut()) - select3(get(), Test.foo(getOut())) - select3(Test.foo(get()), Test.foo(getOut())) - select3(Test.foo(get()), getOut()) - select4(get(), getOut()) - select4(get(), Test.foo(getOut())) - select4(Test.foo(get()), Test.foo(getOut())) - select4(Test.foo(get()), getOut()) + select1(get(), getOut()) + select1(get(), Test.foo(getOut())) + select1(Test.foo(get()), Test.foo(getOut())) + select1(Test.foo(get()), getOut()) + select2(get(), getOut()) + select2(get(), Test.foo(getOut())) + select2(Test.foo(get()), Test.foo(getOut())) + select2(Test.foo(get()), getOut()) + select3(get(), getOut()) + select3(get(), Test.foo(getOut())) + select3(Test.foo(get()), Test.foo(getOut())) + select3(Test.foo(get()), getOut()) + select4(get(), getOut()) + select4(get(), Test.foo(getOut())) + select4(Test.foo(get()), Test.foo(getOut())) + select4(Test.foo(get()), getOut()) - select4(id(Test.foo(get())), getOut()) + select4(id(Test.foo(get())), getOut()) build2 { emit(1) diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeInvariant.fir.kt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeInvariant.fir.kt index cb01221d89c..2841acfe28b 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeInvariant.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeInvariant.fir.kt @@ -66,6 +66,9 @@ fun test() { emit(if (true) "1" else null) select2(get(), getInv()) select2(get(), Test.foo(getInv())) + getInv() + Test.foo(getInv()) + Test.foo(get()) select2(Test.foo(get()), Test.foo(getInv())) select2(Test.foo(get()), getInv()) select3(get(), getInv()) diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeInvariant.kt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeInvariant.kt index acbacf26174..45834f1081d 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeInvariant.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeInvariant.kt @@ -34,29 +34,29 @@ fun select4(x: E?, y: Inv): E = x!! fun test() { val ret1 = build { emit("1") - select1(get(), getInv()) - select1(get(), Test.foo(getInv())) - select1(Test.foo(get()), Test.foo(getInv())) - select1(Test.foo(get()), getInv()) - select4(get(), getInv()) - select4(get(), Test.foo(getInv())) - select4(Test.foo(get()), Test.foo(getInv())) - select4(Test.foo(get()), getInv()) + select1(get(), getInv()) + select1(get(), Test.foo(getInv())) + select1(Test.foo(get()), Test.foo(getInv())) + select1(Test.foo(get()), getInv()) + select4(get(), getInv()) + select4(get(), Test.foo(getInv())) + select4(Test.foo(get()), Test.foo(getInv())) + select4(Test.foo(get()), getInv()) - select4(id(Test.foo(get())), getInv()) + select4(id(Test.foo(get())), getInv()) build2 { emit(1) - select1(this@build.get(), getInv()) - select1(get(), Test.foo(this@build.getInv())) - select1(Test.foo(this@build.get()), Test.foo(getInv())) - select1(Test.foo(get()), this@build.getInv()) - select4(this@build.get(), getInv()) - select4(get(), Test.foo(this@build.getInv())) - select4(Test.foo(this@build.get()), Test.foo(getInv())) - select4(Test.foo(get()), this@build.getInv()) + select1(this@build.get(), getInv()) + select1(get(), Test.foo(this@build.getInv())) + select1(Test.foo(this@build.get()), Test.foo(getInv())) + select1(Test.foo(get()), this@build.getInv()) + select4(this@build.get(), getInv()) + select4(get(), Test.foo(this@build.getInv())) + select4(Test.foo(this@build.get()), Test.foo(getInv())) + select4(Test.foo(get()), this@build.getInv()) - select4(id(Test.foo(this@build.get())), getInv()) + select4(id(Test.foo(this@build.get())), getInv()) "" } "" @@ -64,14 +64,17 @@ fun test() { val ret2 = build { emit(if (true) "1" else null) - select2(get(), getInv()) - select2(get(), Test.foo(getInv())) - select2(Test.foo(get()), Test.foo(getInv())) - select2(Test.foo(get()), getInv()) - select3(get(), getInv()) - select3(get(), Test.foo(getInv())) - select3(Test.foo(get()), Test.foo(getInv())) - select3(Test.foo(get()), getInv()) + select2(get(), getInv()) + select2(get(), Test.foo(getInv())) + ")!>getInv() + ..Inv?)")!>Test.foo(")!>getInv()) + Test.foo(get()) + select2(Test.foo(get()), ..Inv?)")!>Test.foo(")!>getInv())) + select2(Test.foo(get()), getInv()) + select3(get(), getInv()) + select3(get(), Test.foo(getInv())) + select3(Test.foo(get()), Test.foo(getInv())) + select3(Test.foo(get()), getInv()) build2 { emit(1) @@ -79,8 +82,8 @@ fun test() { select2(get(), Test.foo(this@build.getInv())) select2(Test.foo(this@build.get()), Test.foo(getInv())) select2(Test.foo(get()), this@build.getInv()) - select3(this@build.get(), getInv()) - select3(get(), Test.foo(this@build.getInv())) + select3(this@build.get(), getInv()) + select3(get(), Test.foo(this@build.getInv())) select3(Test.foo(this@build.get()), Test.foo(getInv())) select3(Test.foo(get()), this@build.getInv()) "" diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeNullable.fir.kt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeNullable.fir.kt index d9af3813243..c14edc95dee 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeNullable.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeNullable.fir.kt @@ -4,7 +4,7 @@ // FILE: Test.java -import org.jetbrains.annotations.* +import org.jetbrains.annotations.*; class Test { @Nullable diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeNullable.kt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeNullable.kt index 62e467d60d6..742939e1761 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeNullable.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/commonSuperTypeNullable.kt @@ -4,7 +4,7 @@ // FILE: Test.java -import org.jetbrains.annotations.* +import org.jetbrains.annotations.*; class Test { @Nullable @@ -36,15 +36,15 @@ fun test() { emit("1") Test.foo(get()) ?")!>Test.foo(getInv()) - id(get()) - select(get(), get()) - select(Test.foo(get()), Test.foo(get())) - select(Test.foo(get()), get()) - ?")!>select(getInv(), getInv()) - ?")!>select(Test.foo(getInv()), Test.foo(getInv())) - ?")!>select(Test.foo(getInv()), getInv()) - ?")!>select(getInv(), Test.foo(getInv())) - select(id(get()), id(get())) + id(get()) + select(get(), get()) + select(Test.foo(get()), Test.foo(get())) + select(Test.foo(get()), get()) + ?")!>select(getInv(), getInv()) + ?")!>select(Test.foo(getInv()), Test.foo(getInv())) + ?")!>select(Test.foo(getInv()), getInv()) + ?")!>select(getInv(), Test.foo(getInv())) + select(id(get()), id(get())) build2 { emit(1) select(this@build.get(), get()) @@ -59,14 +59,14 @@ fun test() { } val ret2 = build { emit("1") - select(get(), null) - select(Test.foo(null), Test.foo(get())) - select(Test.foo(get()), null) - ?")!>select(null, getInv()) - ?")!>select(Test.foo(getInv()), Test.foo(null)) - ?")!>select(Test.foo(null), getInv()) - ?")!>select(getInv(), Test.foo(null)) - select(id(null), id(get())) + select(get(), null) + select(Test.foo(null), Test.foo(get())) + select(Test.foo(get()), null) + ?")!>select(null, getInv()) + ?")!>select(Test.foo(getInv()), Test.foo(null)) + ?")!>select(Test.foo(null), getInv()) + ?")!>select(getInv(), Test.foo(null)) + select(id(null), id(get())) build2 { emit(1) select(this@build.get(), get(), null) diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/intersect.kt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/intersect.kt index 714b9e6bcd1..bd0e277df10 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/intersect.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/intersect.kt @@ -31,17 +31,17 @@ fun intersect(vararg x: In): E = null as E fun test() { val ret = build { emit("1") - intersect(getIn(), getIn()) - intersect(getIn(), Test.foo(getIn())) - intersect(Test.foo(getIn()), Test.foo(getIn())) - intersect(Test.foo(getIn()), getIn()) + intersect(getIn(), getIn()) + intersect(getIn(), Test.foo(getIn())) + intersect(Test.foo(getIn()), Test.foo(getIn())) + intersect(Test.foo(getIn()), getIn()) build2 { emit(1) - intersect(this@build.getIn(), getIn()) - intersect(getIn(), Test.foo(this@build.getIn())) - intersect(Test.foo(this@build.getIn()), Test.foo(getIn())) - intersect(Test.foo(getIn()), this@build.getIn()) + intersect(this@build.getIn(), getIn()) + intersect(getIn(), Test.foo(this@build.getIn())) + intersect(Test.foo(this@build.getIn()), Test.foo(getIn())) + intersect(Test.foo(getIn()), this@build.getIn()) "" } "" diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/memberScope.fir.kt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/memberScope.fir.kt index b3d4512da3d..0d4fe9b2cdd 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/memberScope.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/memberScope.fir.kt @@ -17,7 +17,7 @@ fun Any.test() {} fun Any?.test2() {} fun test() { - val ret = build { + val ret1 = build { emit(1) emit(null) get()?.test() @@ -27,10 +27,31 @@ fun test() { get()?.equals(1) // there is `String?.equals` extension get().equals("") + } + val ret2 = build { + emit(1) + emit(null) + get()?.test() + get()?.test2() + get().test2() + get()?.hashCode() + get()?.equals(1) val x = get() x?.hashCode() x?.equals(1) x.equals("") + } + val ret3 = build { + emit(1) + emit(null) + get()?.test() + get()?.test2() + get().test2() + get()?.hashCode() + get()?.equals(1) + val x = get() + x?.hashCode() + x?.equals(1) if (get() == null) {} if (get() === null) {} @@ -46,10 +67,27 @@ fun test() { x.test2() } + "" + } + val ret4 = build { + emit(1) + emit(null) + get()?.test() + get()?.test2() + get().test2() + get()?.hashCode() + get()?.equals(1) + val x = get() + x?.hashCode() + x?.equals(1) + + if (get() == null) {} + if (get() === null) {} + if (x == null) { x?.hashCode() x?.equals(1) - x.equals("") + x.equals("") // TODO: is it correct? x.hashCode() x.toString() x.test() @@ -68,6 +106,34 @@ fun test() { x.test2() } + "" + } + val ret5 = build { + emit(1) + emit(null) + get()?.test() + get()?.test2() + get().test2() + get()?.hashCode() + get()?.equals(1) + val x = get() + x?.hashCode() + x?.equals(1) + + if (get() == null) {} + if (get() === null) {} + + if (x == null) { + x?.hashCode() + x?.equals(1) + x.equals("") + x.hashCode() + x.toString() + x.test() + x?.test2() + x.test2() + } + "" } } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/memberScope.kt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/memberScope.kt index a68c53c79fa..fa446ed896a 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/memberScope.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/memberScope.kt @@ -17,7 +17,7 @@ fun Any.test() {} fun Any?.test2() {} fun test() { - val ret = build { + val ret1 = build { emit(1) emit(null) get()?.test() @@ -26,11 +26,32 @@ fun test() { get()?.hashCode() get()?.equals(1) // there is `String?.equals` extension - get().equals("") + get().equals("") + } + val ret2 = build { + emit(1) + emit(null) + get()?.test() + get()?.test2() + get().test2() + get()?.hashCode() + get()?.equals(1) + val x = get() + x?.hashCode() + x?.equals(1) + x.equals("") + } + val ret3 = build { + emit(1) + emit(null) + get()?.test() + get()?.test2() + get().test2() + get()?.hashCode() + get()?.equals(1) val x = get() x?.hashCode() x?.equals(1) - x.equals("") if (get() == null) {} if (get() === null) {} @@ -38,21 +59,38 @@ fun test() { if (x != null) { x?.hashCode() x?.equals(1) - x.equals("") - x.hashCode() - x.toString() - x.test() + x.equals("") + x.hashCode() + x.toString() + x.test() x?.test2() x.test2() } + "" + } + val ret4 = build { + emit(1) + emit(null) + get()?.test() + get()?.test2() + get().test2() + get()?.hashCode() + get()?.equals(1) + val x = get() + x?.hashCode() + x?.equals(1) + + if (get() == null) {} + if (get() === null) {} + if (x == null) { x?.hashCode() x?.equals(1) - x.equals("") + x.equals("") // TODO: is it correct? x.hashCode() x.toString() - x.test() + x.test() x?.test2() x.test2() } @@ -63,7 +101,35 @@ fun test() { x.equals("") x.hashCode() x.toString() - x.test() + x.test() + x?.test2() + x.test2() + } + + "" + } + val ret5 = build { + emit(1) + emit(null) + get()?.test() + get()?.test2() + get().test2() + get()?.hashCode() + get()?.equals(1) + val x = get() + x?.hashCode() + x?.equals(1) + + if (get() == null) {} + if (get() === null) {} + + if (x == null) { + x?.hashCode() + x?.equals(1) + x.equals("") + x.hashCode() + x.toString() + x.test() x?.test2() x.test2() } diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/renderingStubTypes.kt b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/renderingStubTypes.kt index 388222c109a..65d431e1e04 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/renderingStubTypes.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/stubTypes/renderingStubTypes.kt @@ -22,8 +22,8 @@ fun id(x: U) = x fun test() { val ret = build { emit("1") - get() - ")!>getInv() + get() + ")!>getInv() "" } } diff --git a/compiler/testData/diagnostics/tests/inference/commonSystem/lessSpecificTypeForArgumentCallWithExactAnnotation.kt b/compiler/testData/diagnostics/tests/inference/commonSystem/lessSpecificTypeForArgumentCallWithExactAnnotation.kt index 0d324dec1e2..3b73669dac4 100644 --- a/compiler/testData/diagnostics/tests/inference/commonSystem/lessSpecificTypeForArgumentCallWithExactAnnotation.kt +++ b/compiler/testData/diagnostics/tests/inference/commonSystem/lessSpecificTypeForArgumentCallWithExactAnnotation.kt @@ -12,6 +12,6 @@ fun foo(a: Any) {} fun test(b: B, c: C) { foo( - select(b, c) + select(b, c) ) } diff --git a/compiler/testData/diagnostics/tests/inference/commonSystem/postponedCompletionWithExactAnnotation.kt b/compiler/testData/diagnostics/tests/inference/commonSystem/postponedCompletionWithExactAnnotation.kt index 769df3b93eb..f6c90969be4 100644 --- a/compiler/testData/diagnostics/tests/inference/commonSystem/postponedCompletionWithExactAnnotation.kt +++ b/compiler/testData/diagnostics/tests/inference/commonSystem/postponedCompletionWithExactAnnotation.kt @@ -22,7 +22,7 @@ fun test(nullableSample: ISample, any: Any) { ) elvisSimple( - elvisExact(nullableSample, materialize()), + elvisExact(nullableSample, materialize()), any ) } diff --git a/compiler/testData/diagnostics/tests/regressions/kt10843.kt b/compiler/testData/diagnostics/tests/regressions/kt10843.kt index 50a313b667b..dda1b6da3cd 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt10843.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt10843.kt @@ -1,6 +1,6 @@ // NI_EXPECTED_FILE // See EA-76890 / KT-10843: NPE during analysis -fun lambda(x : Int?) = x?.let l { +fun lambda(x : Int?) = x?.let l { y -> if (y > 0) return@l x y diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java index 9d47ab3e32b..5e026db2e66 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java @@ -12686,12 +12686,24 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { runTest("compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorType.kt"); } + @Test + @TestMetadata("specialCallsWithCallableReferencesErrorTypeUnrestricted.kt") + public void testSpecialCallsWithCallableReferencesErrorTypeUnrestricted() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorTypeUnrestricted.kt"); + } + @Test @TestMetadata("specialCallsWithCallableReferencesNonStrictOnlyInputTypes.kt") public void testSpecialCallsWithCallableReferencesNonStrictOnlyInputTypes() throws Exception { runTest("compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesNonStrictOnlyInputTypes.kt"); } + @Test + @TestMetadata("specialCallsWithCallableReferencesUnrestricted.kt") + public void testSpecialCallsWithCallableReferencesUnrestricted() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesUnrestricted.kt"); + } + @Test @TestMetadata("specialCallsWithLambdas.kt") public void testSpecialCallsWithLambdas() throws Exception { @@ -12712,12 +12724,6 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public void testViolating() throws Exception { runTest("compiler/testData/diagnostics/tests/inference/builderInference/constraints/violating.kt"); } - - @Test - @TestMetadata("withExpectedType.kt") - public void testWithExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/builderInference/constraints/withExpectedType.kt"); - } } @Nested diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java index 3dbc32d8aed..8968571aa12 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/BlackBoxCodegenTestGenerated.java @@ -17557,18 +17557,78 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { runTest("compiler/testData/codegen/box/inference/builderInference/callableReferencesProperCompletion.kt"); } + @Test + @TestMetadata("capturedTypes.kt") + public void testCapturedTypes() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/capturedTypes.kt"); + } + + @Test + @TestMetadata("commonSuperType.kt") + public void testCommonSuperType() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperType.kt"); + } + + @Test + @TestMetadata("commonSuperTypeContravariant.kt") + public void testCommonSuperTypeContravariant() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeContravariant.kt"); + } + + @Test + @TestMetadata("commonSuperTypeCovariant.kt") + public void testCommonSuperTypeCovariant() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeCovariant.kt"); + } + + @Test + @TestMetadata("commonSuperTypeInvariant.kt") + public void testCommonSuperTypeInvariant() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeInvariant.kt"); + } + + @Test + @TestMetadata("commonSuperTypeNullable.kt") + public void testCommonSuperTypeNullable() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeNullable.kt"); + } + + @Test + @TestMetadata("intersect.kt") + public void testIntersect() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/intersect.kt"); + } + @Test @TestMetadata("kt41164.kt") public void testKt41164() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/kt41164.kt"); } + @Test + @TestMetadata("labaledCall.kt") + public void testLabaledCall() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/labaledCall.kt"); + } + @Test @TestMetadata("lackOfNullCheckOnNullableInsideBuild.kt") public void testLackOfNullCheckOnNullableInsideBuild() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/lackOfNullCheckOnNullableInsideBuild.kt"); } + @Test + @TestMetadata("memberScope.kt") + public void testMemberScope() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/memberScope.kt"); + } + + @Test + @TestMetadata("nullability.kt") + public void testNullability() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/nullability.kt"); + } + @Test @TestMetadata("propagateInferenceSessionIntoDeclarationAnalyzers.kt") public void testPropagateInferenceSessionIntoDeclarationAnalyzers() throws Exception { @@ -17587,6 +17647,18 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExpression.kt"); } + @Test + @TestMetadata("specialCallsWithCallableReferencesDontCareTypeInBlockExression.kt") + public void testSpecialCallsWithCallableReferencesDontCareTypeInBlockExression() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExression.kt"); + } + + @Test + @TestMetadata("specialCallsWithCallableReferencesDontRewriteAtSlice.kt") + public void testSpecialCallsWithCallableReferencesDontRewriteAtSlice() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontRewriteAtSlice.kt"); + } + @Test @TestMetadata("specialCallsWithCallableReferencesErrorType.kt") public void testSpecialCallsWithCallableReferencesErrorType() throws Exception { @@ -17652,6 +17724,12 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { public void testTopDownCompletionWithTwoBuilderInferenceCalls() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/topDownCompletionWithTwoBuilderInferenceCalls.kt"); } + + @Test + @TestMetadata("withExpectedType.kt") + public void testWithExpectedType() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/withExpectedType.kt"); + } } } diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java index 00d8fa73838..9ff7c3ed7db 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/codegen/IrBlackBoxCodegenTestGenerated.java @@ -17587,18 +17587,78 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes runTest("compiler/testData/codegen/box/inference/builderInference/callableReferencesProperCompletion.kt"); } + @Test + @TestMetadata("capturedTypes.kt") + public void testCapturedTypes() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/capturedTypes.kt"); + } + + @Test + @TestMetadata("commonSuperType.kt") + public void testCommonSuperType() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperType.kt"); + } + + @Test + @TestMetadata("commonSuperTypeContravariant.kt") + public void testCommonSuperTypeContravariant() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeContravariant.kt"); + } + + @Test + @TestMetadata("commonSuperTypeCovariant.kt") + public void testCommonSuperTypeCovariant() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeCovariant.kt"); + } + + @Test + @TestMetadata("commonSuperTypeInvariant.kt") + public void testCommonSuperTypeInvariant() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeInvariant.kt"); + } + + @Test + @TestMetadata("commonSuperTypeNullable.kt") + public void testCommonSuperTypeNullable() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeNullable.kt"); + } + + @Test + @TestMetadata("intersect.kt") + public void testIntersect() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/intersect.kt"); + } + @Test @TestMetadata("kt41164.kt") public void testKt41164() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/kt41164.kt"); } + @Test + @TestMetadata("labaledCall.kt") + public void testLabaledCall() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/labaledCall.kt"); + } + @Test @TestMetadata("lackOfNullCheckOnNullableInsideBuild.kt") public void testLackOfNullCheckOnNullableInsideBuild() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/lackOfNullCheckOnNullableInsideBuild.kt"); } + @Test + @TestMetadata("memberScope.kt") + public void testMemberScope() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/memberScope.kt"); + } + + @Test + @TestMetadata("nullability.kt") + public void testNullability() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/nullability.kt"); + } + @Test @TestMetadata("propagateInferenceSessionIntoDeclarationAnalyzers.kt") public void testPropagateInferenceSessionIntoDeclarationAnalyzers() throws Exception { @@ -17617,6 +17677,18 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExpression.kt"); } + @Test + @TestMetadata("specialCallsWithCallableReferencesDontCareTypeInBlockExression.kt") + public void testSpecialCallsWithCallableReferencesDontCareTypeInBlockExression() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExression.kt"); + } + + @Test + @TestMetadata("specialCallsWithCallableReferencesDontRewriteAtSlice.kt") + public void testSpecialCallsWithCallableReferencesDontRewriteAtSlice() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontRewriteAtSlice.kt"); + } + @Test @TestMetadata("specialCallsWithCallableReferencesErrorType.kt") public void testSpecialCallsWithCallableReferencesErrorType() throws Exception { @@ -17682,6 +17754,12 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes public void testTopDownCompletionWithTwoBuilderInferenceCalls() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/topDownCompletionWithTwoBuilderInferenceCalls.kt"); } + + @Test + @TestMetadata("withExpectedType.kt") + public void testWithExpectedType() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/withExpectedType.kt"); + } } } diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java index 668759668b2..938b853658d 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -14536,16 +14536,66 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes runTest("compiler/testData/codegen/box/inference/builderInference/callableReferencesProperCompletion.kt"); } + @TestMetadata("capturedTypes.kt") + public void testCapturedTypes() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/capturedTypes.kt"); + } + + @TestMetadata("commonSuperType.kt") + public void testCommonSuperType() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperType.kt"); + } + + @TestMetadata("commonSuperTypeContravariant.kt") + public void testCommonSuperTypeContravariant() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeContravariant.kt"); + } + + @TestMetadata("commonSuperTypeCovariant.kt") + public void testCommonSuperTypeCovariant() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeCovariant.kt"); + } + + @TestMetadata("commonSuperTypeInvariant.kt") + public void testCommonSuperTypeInvariant() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeInvariant.kt"); + } + + @TestMetadata("commonSuperTypeNullable.kt") + public void testCommonSuperTypeNullable() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeNullable.kt"); + } + + @TestMetadata("intersect.kt") + public void testIntersect() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/intersect.kt"); + } + @TestMetadata("kt41164.kt") public void testKt41164() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/kt41164.kt"); } + @TestMetadata("labaledCall.kt") + public void testLabaledCall() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/labaledCall.kt"); + } + @TestMetadata("lackOfNullCheckOnNullableInsideBuild.kt") public void testLackOfNullCheckOnNullableInsideBuild() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/lackOfNullCheckOnNullableInsideBuild.kt"); } + @TestMetadata("memberScope.kt") + public void testMemberScope() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/memberScope.kt"); + } + + @TestMetadata("nullability.kt") + public void testNullability() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/nullability.kt"); + } + @TestMetadata("propagateInferenceSessionIntoDeclarationAnalyzers.kt") public void testPropagateInferenceSessionIntoDeclarationAnalyzers() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/propagateInferenceSessionIntoDeclarationAnalyzers.kt"); @@ -14561,6 +14611,16 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExpression.kt"); } + @TestMetadata("specialCallsWithCallableReferencesDontCareTypeInBlockExression.kt") + public void testSpecialCallsWithCallableReferencesDontCareTypeInBlockExression() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExression.kt"); + } + + @TestMetadata("specialCallsWithCallableReferencesDontRewriteAtSlice.kt") + public void testSpecialCallsWithCallableReferencesDontRewriteAtSlice() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontRewriteAtSlice.kt"); + } + @TestMetadata("specialCallsWithCallableReferencesErrorType.kt") public void testSpecialCallsWithCallableReferencesErrorType() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesErrorType.kt"); @@ -14615,6 +14675,11 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes public void testTopDownCompletionWithTwoBuilderInferenceCalls() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/topDownCompletionWithTwoBuilderInferenceCalls.kt"); } + + @TestMetadata("withExpectedType.kt") + public void testWithExpectedType() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/withExpectedType.kt"); + } } } diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java index fc6227c1ead..f6adbbae52b 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java @@ -12730,16 +12730,66 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes runTest("compiler/testData/codegen/box/inference/builderInference/callableReferencesProperCompletion.kt"); } + @TestMetadata("capturedTypes.kt") + public void testCapturedTypes() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/capturedTypes.kt"); + } + + @TestMetadata("commonSuperType.kt") + public void testCommonSuperType() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperType.kt"); + } + + @TestMetadata("commonSuperTypeContravariant.kt") + public void testCommonSuperTypeContravariant() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeContravariant.kt"); + } + + @TestMetadata("commonSuperTypeCovariant.kt") + public void testCommonSuperTypeCovariant() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeCovariant.kt"); + } + + @TestMetadata("commonSuperTypeInvariant.kt") + public void testCommonSuperTypeInvariant() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeInvariant.kt"); + } + + @TestMetadata("commonSuperTypeNullable.kt") + public void testCommonSuperTypeNullable() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeNullable.kt"); + } + + @TestMetadata("intersect.kt") + public void testIntersect() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/intersect.kt"); + } + @TestMetadata("kt41164.kt") public void testKt41164() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/kt41164.kt"); } + @TestMetadata("labaledCall.kt") + public void testLabaledCall() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/labaledCall.kt"); + } + @TestMetadata("lackOfNullCheckOnNullableInsideBuild.kt") public void testLackOfNullCheckOnNullableInsideBuild() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/lackOfNullCheckOnNullableInsideBuild.kt"); } + @TestMetadata("memberScope.kt") + public void testMemberScope() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/memberScope.kt"); + } + + @TestMetadata("nullability.kt") + public void testNullability() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/nullability.kt"); + } + @TestMetadata("propagateInferenceSessionIntoDeclarationAnalyzers.kt") public void testPropagateInferenceSessionIntoDeclarationAnalyzers() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/propagateInferenceSessionIntoDeclarationAnalyzers.kt"); @@ -12755,6 +12805,16 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExpression.kt"); } + @TestMetadata("specialCallsWithCallableReferencesDontCareTypeInBlockExression.kt") + public void testSpecialCallsWithCallableReferencesDontCareTypeInBlockExression() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExression.kt"); + } + + @TestMetadata("specialCallsWithCallableReferencesDontRewriteAtSlice.kt") + public void testSpecialCallsWithCallableReferencesDontRewriteAtSlice() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontRewriteAtSlice.kt"); + } + @TestMetadata("specialCallsWithCallableReferencesErrorType.kt") public void testSpecialCallsWithCallableReferencesErrorType() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesErrorType.kt"); @@ -12804,6 +12864,11 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes public void testTopDownCompletionWithTwoBuilderInferenceCalls() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/topDownCompletionWithTwoBuilderInferenceCalls.kt"); } + + @TestMetadata("withExpectedType.kt") + public void testWithExpectedType() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/withExpectedType.kt"); + } } } diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java index 62bdad27b15..ef68cc8b867 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java @@ -12136,16 +12136,66 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { runTest("compiler/testData/codegen/box/inference/builderInference/callableReferencesProperCompletion.kt"); } + @TestMetadata("capturedTypes.kt") + public void testCapturedTypes() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/capturedTypes.kt"); + } + + @TestMetadata("commonSuperType.kt") + public void testCommonSuperType() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperType.kt"); + } + + @TestMetadata("commonSuperTypeContravariant.kt") + public void testCommonSuperTypeContravariant() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeContravariant.kt"); + } + + @TestMetadata("commonSuperTypeCovariant.kt") + public void testCommonSuperTypeCovariant() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeCovariant.kt"); + } + + @TestMetadata("commonSuperTypeInvariant.kt") + public void testCommonSuperTypeInvariant() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeInvariant.kt"); + } + + @TestMetadata("commonSuperTypeNullable.kt") + public void testCommonSuperTypeNullable() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeNullable.kt"); + } + + @TestMetadata("intersect.kt") + public void testIntersect() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/intersect.kt"); + } + @TestMetadata("kt41164.kt") public void testKt41164() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/kt41164.kt"); } + @TestMetadata("labaledCall.kt") + public void testLabaledCall() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/labaledCall.kt"); + } + @TestMetadata("lackOfNullCheckOnNullableInsideBuild.kt") public void testLackOfNullCheckOnNullableInsideBuild() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/lackOfNullCheckOnNullableInsideBuild.kt"); } + @TestMetadata("memberScope.kt") + public void testMemberScope() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/memberScope.kt"); + } + + @TestMetadata("nullability.kt") + public void testNullability() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/nullability.kt"); + } + @TestMetadata("propagateInferenceSessionIntoDeclarationAnalyzers.kt") public void testPropagateInferenceSessionIntoDeclarationAnalyzers() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/propagateInferenceSessionIntoDeclarationAnalyzers.kt"); @@ -12161,6 +12211,16 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExpression.kt"); } + @TestMetadata("specialCallsWithCallableReferencesDontCareTypeInBlockExression.kt") + public void testSpecialCallsWithCallableReferencesDontCareTypeInBlockExression() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExression.kt"); + } + + @TestMetadata("specialCallsWithCallableReferencesDontRewriteAtSlice.kt") + public void testSpecialCallsWithCallableReferencesDontRewriteAtSlice() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontRewriteAtSlice.kt"); + } + @TestMetadata("specialCallsWithCallableReferencesErrorType.kt") public void testSpecialCallsWithCallableReferencesErrorType() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesErrorType.kt"); @@ -12210,6 +12270,11 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { public void testTopDownCompletionWithTwoBuilderInferenceCalls() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/topDownCompletionWithTwoBuilderInferenceCalls.kt"); } + + @TestMetadata("withExpectedType.kt") + public void testWithExpectedType() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/withExpectedType.kt"); + } } } diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java index 571debd2f1d..46101fb904c 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java @@ -12201,16 +12201,66 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { runTest("compiler/testData/codegen/box/inference/builderInference/callableReferencesProperCompletion.kt"); } + @TestMetadata("capturedTypes.kt") + public void testCapturedTypes() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/capturedTypes.kt"); + } + + @TestMetadata("commonSuperType.kt") + public void testCommonSuperType() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperType.kt"); + } + + @TestMetadata("commonSuperTypeContravariant.kt") + public void testCommonSuperTypeContravariant() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeContravariant.kt"); + } + + @TestMetadata("commonSuperTypeCovariant.kt") + public void testCommonSuperTypeCovariant() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeCovariant.kt"); + } + + @TestMetadata("commonSuperTypeInvariant.kt") + public void testCommonSuperTypeInvariant() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeInvariant.kt"); + } + + @TestMetadata("commonSuperTypeNullable.kt") + public void testCommonSuperTypeNullable() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeNullable.kt"); + } + + @TestMetadata("intersect.kt") + public void testIntersect() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/intersect.kt"); + } + @TestMetadata("kt41164.kt") public void testKt41164() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/kt41164.kt"); } + @TestMetadata("labaledCall.kt") + public void testLabaledCall() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/labaledCall.kt"); + } + @TestMetadata("lackOfNullCheckOnNullableInsideBuild.kt") public void testLackOfNullCheckOnNullableInsideBuild() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/lackOfNullCheckOnNullableInsideBuild.kt"); } + @TestMetadata("memberScope.kt") + public void testMemberScope() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/memberScope.kt"); + } + + @TestMetadata("nullability.kt") + public void testNullability() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/nullability.kt"); + } + @TestMetadata("propagateInferenceSessionIntoDeclarationAnalyzers.kt") public void testPropagateInferenceSessionIntoDeclarationAnalyzers() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/propagateInferenceSessionIntoDeclarationAnalyzers.kt"); @@ -12226,6 +12276,16 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExpression.kt"); } + @TestMetadata("specialCallsWithCallableReferencesDontCareTypeInBlockExression.kt") + public void testSpecialCallsWithCallableReferencesDontCareTypeInBlockExression() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExression.kt"); + } + + @TestMetadata("specialCallsWithCallableReferencesDontRewriteAtSlice.kt") + public void testSpecialCallsWithCallableReferencesDontRewriteAtSlice() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontRewriteAtSlice.kt"); + } + @TestMetadata("specialCallsWithCallableReferencesErrorType.kt") public void testSpecialCallsWithCallableReferencesErrorType() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesErrorType.kt"); @@ -12275,6 +12335,11 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { public void testTopDownCompletionWithTwoBuilderInferenceCalls() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/topDownCompletionWithTwoBuilderInferenceCalls.kt"); } + + @TestMetadata("withExpectedType.kt") + public void testWithExpectedType() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/withExpectedType.kt"); + } } } diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/wasm/semantics/IrCodegenBoxWasmTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/wasm/semantics/IrCodegenBoxWasmTestGenerated.java index 7f2ecc67c0a..d999d30ac28 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/wasm/semantics/IrCodegenBoxWasmTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/wasm/semantics/IrCodegenBoxWasmTestGenerated.java @@ -6491,25 +6491,90 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inference/builderInference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @TestMetadata("capturedTypes.kt") + public void testCapturedTypes() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/capturedTypes.kt"); + } + + @TestMetadata("commonSuperType.kt") + public void testCommonSuperType() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperType.kt"); + } + + @TestMetadata("commonSuperTypeContravariant.kt") + public void testCommonSuperTypeContravariant() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeContravariant.kt"); + } + + @TestMetadata("commonSuperTypeCovariant.kt") + public void testCommonSuperTypeCovariant() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeCovariant.kt"); + } + + @TestMetadata("commonSuperTypeInvariant.kt") + public void testCommonSuperTypeInvariant() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeInvariant.kt"); + } + + @TestMetadata("commonSuperTypeNullable.kt") + public void testCommonSuperTypeNullable() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/commonSuperTypeNullable.kt"); + } + + @TestMetadata("intersect.kt") + public void testIntersect() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/intersect.kt"); + } + @TestMetadata("kt41164.kt") public void testKt41164() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/kt41164.kt"); } + @TestMetadata("labaledCall.kt") + public void testLabaledCall() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/labaledCall.kt"); + } + @TestMetadata("lackOfNullCheckOnNullableInsideBuild.kt") public void testLackOfNullCheckOnNullableInsideBuild() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/lackOfNullCheckOnNullableInsideBuild.kt"); } + @TestMetadata("memberScope.kt") + public void testMemberScope() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/memberScope.kt"); + } + + @TestMetadata("nullability.kt") + public void testNullability() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/nullability.kt"); + } + @TestMetadata("propagateInferenceSessionIntoDeclarationAnalyzers.kt") public void testPropagateInferenceSessionIntoDeclarationAnalyzers() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/propagateInferenceSessionIntoDeclarationAnalyzers.kt"); } + @TestMetadata("specialCallsWithCallableReferencesDontCareTypeInBlockExression.kt") + public void testSpecialCallsWithCallableReferencesDontCareTypeInBlockExression() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExression.kt"); + } + + @TestMetadata("specialCallsWithCallableReferencesDontRewriteAtSlice.kt") + public void testSpecialCallsWithCallableReferencesDontRewriteAtSlice() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontRewriteAtSlice.kt"); + } + @TestMetadata("substituteStubTypeIntolambdaParameterDescriptor.kt") public void testSubstituteStubTypeIntolambdaParameterDescriptor() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/substituteStubTypeIntolambdaParameterDescriptor.kt"); } + + @TestMetadata("withExpectedType.kt") + public void testWithExpectedType() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/withExpectedType.kt"); + } } }