From cff0865c872585d83f459830cf83a75d0286fa48 Mon Sep 17 00:00:00 2001 From: Mikhail Zarechenskiy Date: Mon, 9 Jan 2017 22:02:54 +0300 Subject: [PATCH] Fix error type for implicit invoke with function literal argument #KT-11401 Fixed --- .../resolve/calls/GenericCandidateResolver.kt | 20 +++++++--- ...InCompanionObjectWithFunctionalArgument.kt | 14 +++++++ ...plicitInvokeWithFunctionLiteralArgument.kt | 10 +++++ ...nCompanionObjectWithFunctionalArgument.txt | 18 +++++++++ ...licitInvokeWithFunctionLiteralArgument.txt | 10 +++++ ...nCompanionObjectWithFunctionalArgument.txt | 18 +++++++++ ...licitInvokeWithFunctionLiteralArgument.txt | 10 +++++ ...itInvokeExtensionWithFunctionalArgument.kt | 28 ++++++++++++++ ...tInvokeExtensionWithFunctionalArgument.txt | 28 ++++++++++++++ ...InCompanionObjectWithFunctionalArgument.kt | 16 ++++++++ ...nCompanionObjectWithFunctionalArgument.txt | 18 +++++++++ ...citInvokeInObjectWithFunctionalArgument.kt | 14 +++++++ ...itInvokeInObjectWithFunctionalArgument.txt | 11 ++++++ ...plicitInvokeWithFunctionLiteralArgument.kt | 37 +++++++++++++++++++ ...licitInvokeWithFunctionLiteralArgument.txt | 26 +++++++++++++ .../ir/IrBlackBoxCodegenTestGenerated.java | 12 ++++++ .../checkers/DiagnosticsTestGenerated.java | 24 ++++++++++++ .../codegen/BlackBoxCodegenTestGenerated.java | 12 ++++++ ...LightAnalysisModeCodegenTestGenerated.java | 12 ++++++ .../intentions/IntentionTestGenerated.java | 2 +- .../idea/quickfix/QuickFixTestGenerated.java | 2 +- .../semantics/JsCodegenBoxTestGenerated.java | 12 ++++++ 22 files changed, 347 insertions(+), 7 deletions(-) create mode 100644 compiler/testData/codegen/box/functions/invoke/implicitInvokeInCompanionObjectWithFunctionalArgument.kt create mode 100644 compiler/testData/codegen/box/functions/invoke/implicitInvokeWithFunctionLiteralArgument.kt create mode 100644 compiler/testData/codegen/light-analysis/diagnostics/functions/invoke/onObjects/implicitInvokeInCompanionObjectWithFunctionalArgument.txt create mode 100644 compiler/testData/codegen/light-analysis/diagnostics/functions/invoke/onObjects/implicitInvokeWithFunctionLiteralArgument.txt create mode 100644 compiler/testData/codegen/light-analysis/functions/invoke/implicitInvokeInCompanionObjectWithFunctionalArgument.txt create mode 100644 compiler/testData/codegen/light-analysis/functions/invoke/implicitInvokeWithFunctionLiteralArgument.txt create mode 100644 compiler/testData/diagnostics/tests/inference/implicitInvokeExtensionWithFunctionalArgument.kt create mode 100644 compiler/testData/diagnostics/tests/inference/implicitInvokeExtensionWithFunctionalArgument.txt create mode 100644 compiler/testData/diagnostics/tests/inference/implicitInvokeInCompanionObjectWithFunctionalArgument.kt create mode 100644 compiler/testData/diagnostics/tests/inference/implicitInvokeInCompanionObjectWithFunctionalArgument.txt create mode 100644 compiler/testData/diagnostics/tests/inference/implicitInvokeInObjectWithFunctionalArgument.kt create mode 100644 compiler/testData/diagnostics/tests/inference/implicitInvokeInObjectWithFunctionalArgument.txt create mode 100644 compiler/testData/diagnostics/tests/inference/implicitInvokeWithFunctionLiteralArgument.kt create mode 100644 compiler/testData/diagnostics/tests/inference/implicitInvokeWithFunctionLiteralArgument.txt diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/GenericCandidateResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/GenericCandidateResolver.kt index e0487b22b7e..706445bd2df 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/GenericCandidateResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/GenericCandidateResolver.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2016 JetBrains s.r.o. + * Copyright 2010-2017 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -41,6 +41,7 @@ import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.Constrain import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.RECEIVER_POSITION import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.VALUE_PARAMETER_POSITION import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ValidityConstraintForConstituentType +import org.jetbrains.kotlin.resolve.calls.model.VariableAsFunctionResolvedCall import org.jetbrains.kotlin.resolve.calls.resolvedCallUtil.makeNullableTypeIfSafeReceiver import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus.INCOMPLETE_TYPE_INFERENCE @@ -254,17 +255,26 @@ class GenericCandidateResolver( val resolvedCall = context.candidateCall val constraintSystem = resolvedCall.constraintSystem?.toBuilder() ?: return + // `resolvedCall` can contain wrapped call (e.g. CallForImplicitInvoke). Meanwhile, `context` contains simple call which leads + // to inconsistency and errors in inference. See definition of `effectiveExpectedTypeInSystem` in `addConstraintForFunctionLiteralArgument` + val newContext = if (resolvedCall is VariableAsFunctionResolvedCall) { + CallCandidateResolutionContext.create( + resolvedCall, context, context.trace, context.tracing, resolvedCall.functionCall.call, context.candidateResolveMode) + } else { + context + } + // constraints for function literals // Value parameters for ((valueParameterDescriptor, resolvedValueArgument) in resolvedCall.valueArguments) { for (valueArgument in resolvedValueArgument.arguments) { valueArgument.getArgumentExpression()?.let { argumentExpression -> - ArgumentTypeResolver.getFunctionLiteralArgumentIfAny(argumentExpression, context)?.let { functionLiteral -> - addConstraintForFunctionLiteralArgument(functionLiteral, valueArgument, valueParameterDescriptor, constraintSystem, context, + ArgumentTypeResolver.getFunctionLiteralArgumentIfAny(argumentExpression, newContext)?.let { functionLiteral -> + addConstraintForFunctionLiteralArgument(functionLiteral, valueArgument, valueParameterDescriptor, constraintSystem, newContext, resolvedCall.candidateDescriptor.returnType) } - ArgumentTypeResolver.getCallableReferenceExpressionIfAny(argumentExpression, context)?.let { callableReference -> - addConstraintForCallableReference(callableReference, valueArgument, valueParameterDescriptor, constraintSystem, context) + ArgumentTypeResolver.getCallableReferenceExpressionIfAny(argumentExpression, newContext)?.let { callableReference -> + addConstraintForCallableReference(callableReference, valueArgument, valueParameterDescriptor, constraintSystem, newContext) } } } diff --git a/compiler/testData/codegen/box/functions/invoke/implicitInvokeInCompanionObjectWithFunctionalArgument.kt b/compiler/testData/codegen/box/functions/invoke/implicitInvokeInCompanionObjectWithFunctionalArgument.kt new file mode 100644 index 00000000000..f277bae8b6e --- /dev/null +++ b/compiler/testData/codegen/box/functions/invoke/implicitInvokeInCompanionObjectWithFunctionalArgument.kt @@ -0,0 +1,14 @@ +class TestClass { + companion object { + inline operator fun invoke(task: () -> T) = task() + } +} + +fun box(): String { + val test1 = TestClass { "K" } + if (test1 != "K") return "fail1, 'test1' == $test1" + + val ok = "OK" + + val x = TestClass { return ok } +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/functions/invoke/implicitInvokeWithFunctionLiteralArgument.kt b/compiler/testData/codegen/box/functions/invoke/implicitInvokeWithFunctionLiteralArgument.kt new file mode 100644 index 00000000000..de3ac9fbc73 --- /dev/null +++ b/compiler/testData/codegen/box/functions/invoke/implicitInvokeWithFunctionLiteralArgument.kt @@ -0,0 +1,10 @@ +class TestClass { + inline operator fun invoke(task: () -> T) = task() +} + +fun box(): String { + val test = TestClass() + val ok = "OK" + + val x = test { return ok } +} \ No newline at end of file diff --git a/compiler/testData/codegen/light-analysis/diagnostics/functions/invoke/onObjects/implicitInvokeInCompanionObjectWithFunctionalArgument.txt b/compiler/testData/codegen/light-analysis/diagnostics/functions/invoke/onObjects/implicitInvokeInCompanionObjectWithFunctionalArgument.txt new file mode 100644 index 00000000000..dbcefc8caae --- /dev/null +++ b/compiler/testData/codegen/light-analysis/diagnostics/functions/invoke/onObjects/implicitInvokeInCompanionObjectWithFunctionalArgument.txt @@ -0,0 +1,18 @@ +@kotlin.Metadata +public final class ImplicitInvokeInCompanionObjectWithFunctionalArgumentKt { + public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String +} + +@kotlin.Metadata +public final class TestClass { + public final static field Companion: TestClass.Companion + inner class TestClass/Companion + public method (): void +} + +@kotlin.Metadata +public final static class TestClass/Companion { + inner class TestClass/Companion + private method (): void + public final method invoke(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function0): java.lang.Object +} diff --git a/compiler/testData/codegen/light-analysis/diagnostics/functions/invoke/onObjects/implicitInvokeWithFunctionLiteralArgument.txt b/compiler/testData/codegen/light-analysis/diagnostics/functions/invoke/onObjects/implicitInvokeWithFunctionLiteralArgument.txt new file mode 100644 index 00000000000..cc144ed675d --- /dev/null +++ b/compiler/testData/codegen/light-analysis/diagnostics/functions/invoke/onObjects/implicitInvokeWithFunctionLiteralArgument.txt @@ -0,0 +1,10 @@ +@kotlin.Metadata +public final class ImplicitInvokeWithFunctionLiteralArgumentKt { + public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String +} + +@kotlin.Metadata +public final class TestClass { + public method (): void + public final method invoke(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function0): java.lang.Object +} diff --git a/compiler/testData/codegen/light-analysis/functions/invoke/implicitInvokeInCompanionObjectWithFunctionalArgument.txt b/compiler/testData/codegen/light-analysis/functions/invoke/implicitInvokeInCompanionObjectWithFunctionalArgument.txt new file mode 100644 index 00000000000..dbcefc8caae --- /dev/null +++ b/compiler/testData/codegen/light-analysis/functions/invoke/implicitInvokeInCompanionObjectWithFunctionalArgument.txt @@ -0,0 +1,18 @@ +@kotlin.Metadata +public final class ImplicitInvokeInCompanionObjectWithFunctionalArgumentKt { + public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String +} + +@kotlin.Metadata +public final class TestClass { + public final static field Companion: TestClass.Companion + inner class TestClass/Companion + public method (): void +} + +@kotlin.Metadata +public final static class TestClass/Companion { + inner class TestClass/Companion + private method (): void + public final method invoke(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function0): java.lang.Object +} diff --git a/compiler/testData/codegen/light-analysis/functions/invoke/implicitInvokeWithFunctionLiteralArgument.txt b/compiler/testData/codegen/light-analysis/functions/invoke/implicitInvokeWithFunctionLiteralArgument.txt new file mode 100644 index 00000000000..cc144ed675d --- /dev/null +++ b/compiler/testData/codegen/light-analysis/functions/invoke/implicitInvokeWithFunctionLiteralArgument.txt @@ -0,0 +1,10 @@ +@kotlin.Metadata +public final class ImplicitInvokeWithFunctionLiteralArgumentKt { + public final static @org.jetbrains.annotations.NotNull method box(): java.lang.String +} + +@kotlin.Metadata +public final class TestClass { + public method (): void + public final method invoke(@org.jetbrains.annotations.NotNull p0: kotlin.jvm.functions.Function0): java.lang.Object +} diff --git a/compiler/testData/diagnostics/tests/inference/implicitInvokeExtensionWithFunctionalArgument.kt b/compiler/testData/diagnostics/tests/inference/implicitInvokeExtensionWithFunctionalArgument.kt new file mode 100644 index 00000000000..ffa8e33ab09 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/implicitInvokeExtensionWithFunctionalArgument.kt @@ -0,0 +1,28 @@ +// !CHECK_TYPE +// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE + +class AbstractSelector +class SelectorFor + +inline operator fun SelectorFor.invoke(f: S.() -> I): AbstractSelector = TODO() + +class State(val p1: Double, val p2: () -> Int, val p3: String?) + +fun test(s: SelectorFor): Double { + val a = s { p1 } + a checkType { _>() } + + val b = s { p2 } + b checkType { _ Int>>()} + + val c = s { p3 } + c checkType { _>() } + + val d = s { } + d checkType { _>() } + + val e = s { return p1 } + e checkType { _>() } + + return null!! +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/inference/implicitInvokeExtensionWithFunctionalArgument.txt b/compiler/testData/diagnostics/tests/inference/implicitInvokeExtensionWithFunctionalArgument.txt new file mode 100644 index 00000000000..3b1fbb99539 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/implicitInvokeExtensionWithFunctionalArgument.txt @@ -0,0 +1,28 @@ +package + +public fun test(/*0*/ s: SelectorFor): kotlin.Double +public operator inline fun SelectorFor.invoke(/*0*/ f: S.() -> I): AbstractSelector + +public final class AbstractSelector { + public constructor AbstractSelector() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class SelectorFor { + public constructor SelectorFor() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class State { + public constructor State(/*0*/ p1: kotlin.Double, /*1*/ p2: () -> kotlin.Int, /*2*/ p3: kotlin.String?) + public final val p1: kotlin.Double + public final val p2: () -> kotlin.Int + public final val p3: kotlin.String? + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/diagnostics/tests/inference/implicitInvokeInCompanionObjectWithFunctionalArgument.kt b/compiler/testData/diagnostics/tests/inference/implicitInvokeInCompanionObjectWithFunctionalArgument.kt new file mode 100644 index 00000000000..9394ac708a4 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/implicitInvokeInCompanionObjectWithFunctionalArgument.kt @@ -0,0 +1,16 @@ +// !CHECK_TYPE +// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE + +class TestClass { + companion object { + inline operator fun invoke(task: () -> T) = task() + } +} + +fun test(s: String): String { + val a = TestClass { "K" } + a checkType { _() } + + val b = TestClass { return s } + b checkType { _() } +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/inference/implicitInvokeInCompanionObjectWithFunctionalArgument.txt b/compiler/testData/diagnostics/tests/inference/implicitInvokeInCompanionObjectWithFunctionalArgument.txt new file mode 100644 index 00000000000..b1321f1a2f2 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/implicitInvokeInCompanionObjectWithFunctionalArgument.txt @@ -0,0 +1,18 @@ +package + +public fun test(/*0*/ s: kotlin.String): kotlin.String + +public final class TestClass { + public constructor TestClass() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public companion object Companion { + private constructor Companion() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public final operator inline fun invoke(/*0*/ task: () -> T): T + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/testData/diagnostics/tests/inference/implicitInvokeInObjectWithFunctionalArgument.kt b/compiler/testData/diagnostics/tests/inference/implicitInvokeInObjectWithFunctionalArgument.kt new file mode 100644 index 00000000000..bb85a8fa1bd --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/implicitInvokeInObjectWithFunctionalArgument.kt @@ -0,0 +1,14 @@ +// !CHECK_TYPE +// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE + +object TestClass { + inline operator fun invoke(task: () -> T) = task() +} + +fun test(s: String): String { + val a = TestClass { TestClass { TestClass } } + a checkType { _() } + + val b = TestClass { return s } + b checkType { _() } +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/inference/implicitInvokeInObjectWithFunctionalArgument.txt b/compiler/testData/diagnostics/tests/inference/implicitInvokeInObjectWithFunctionalArgument.txt new file mode 100644 index 00000000000..fbcd6ad806b --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/implicitInvokeInObjectWithFunctionalArgument.txt @@ -0,0 +1,11 @@ +package + +public fun test(/*0*/ s: kotlin.String): kotlin.String + +public object TestClass { + private constructor TestClass() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public final operator inline fun invoke(/*0*/ task: () -> T): T + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/testData/diagnostics/tests/inference/implicitInvokeWithFunctionLiteralArgument.kt b/compiler/testData/diagnostics/tests/inference/implicitInvokeWithFunctionLiteralArgument.kt new file mode 100644 index 00000000000..ecd2ad7d1f1 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/implicitInvokeWithFunctionLiteralArgument.kt @@ -0,0 +1,37 @@ +// !CHECK_TYPE +// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE + +class TestClass { + inline operator fun invoke(task: () -> T) = task() +} + +fun test(value: T, test: TestClass): T { + val x = test { return value } + x checkType { _() } + + return value +} + +// --- + +class Future + +interface FutureCallback { + operator fun invoke(f: (E) -> T): Future +} + +fun test(cb: FutureCallback) { + val a = cb { it[0] } + a checkType { _>() } + + val b = cb { it } + b checkType { _>() } + + val c = cb {} + c checkType { _>() } + + cb.let { callback -> + val d = callback { it.length } + d checkType { _>() } + } +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/inference/implicitInvokeWithFunctionLiteralArgument.txt b/compiler/testData/diagnostics/tests/inference/implicitInvokeWithFunctionLiteralArgument.txt new file mode 100644 index 00000000000..0baa81b1376 --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/implicitInvokeWithFunctionLiteralArgument.txt @@ -0,0 +1,26 @@ +package + +public fun test(/*0*/ cb: FutureCallback): kotlin.Unit +public fun test(/*0*/ value: T, /*1*/ test: TestClass): T + +public final class Future { + public constructor Future() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public interface FutureCallback { + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public abstract operator fun invoke(/*0*/ f: (E) -> T): Future + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class TestClass { + public constructor TestClass() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public final operator inline fun invoke(/*0*/ task: () -> T): T + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/tests-ir-jvm/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java b/compiler/tests-ir-jvm/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java index 60d8d2e26e2..4219dd399bc 100644 --- a/compiler/tests-ir-jvm/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java +++ b/compiler/tests-ir-jvm/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java @@ -7744,6 +7744,18 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes doTest(fileName); } + @TestMetadata("implicitInvokeInCompanionObjectWithFunctionalArgument.kt") + public void testImplicitInvokeInCompanionObjectWithFunctionalArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/functions/invoke/implicitInvokeInCompanionObjectWithFunctionalArgument.kt"); + doTest(fileName); + } + + @TestMetadata("implicitInvokeWithFunctionLiteralArgument.kt") + public void testImplicitInvokeWithFunctionLiteralArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/functions/invoke/implicitInvokeWithFunctionLiteralArgument.kt"); + doTest(fileName); + } + @TestMetadata("invoke.kt") public void testInvoke() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/functions/invoke/invoke.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java index 8c99cfc5fb1..ae5b4399590 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java @@ -9922,6 +9922,30 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest { doTest(fileName); } + @TestMetadata("implicitInvokeExtensionWithFunctionalArgument.kt") + public void testImplicitInvokeExtensionWithFunctionalArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/implicitInvokeExtensionWithFunctionalArgument.kt"); + doTest(fileName); + } + + @TestMetadata("implicitInvokeInCompanionObjectWithFunctionalArgument.kt") + public void testImplicitInvokeInCompanionObjectWithFunctionalArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/implicitInvokeInCompanionObjectWithFunctionalArgument.kt"); + doTest(fileName); + } + + @TestMetadata("implicitInvokeInObjectWithFunctionalArgument.kt") + public void testImplicitInvokeInObjectWithFunctionalArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/implicitInvokeInObjectWithFunctionalArgument.kt"); + doTest(fileName); + } + + @TestMetadata("implicitInvokeWithFunctionLiteralArgument.kt") + public void testImplicitInvokeWithFunctionLiteralArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/implicitInvokeWithFunctionLiteralArgument.kt"); + doTest(fileName); + } + @TestMetadata("inferInFunctionLiterals.kt") public void testInferInFunctionLiterals() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inference/inferInFunctionLiterals.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java index 201db3093b7..26cbae442ca 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java @@ -7744,6 +7744,18 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { doTest(fileName); } + @TestMetadata("implicitInvokeInCompanionObjectWithFunctionalArgument.kt") + public void testImplicitInvokeInCompanionObjectWithFunctionalArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/functions/invoke/implicitInvokeInCompanionObjectWithFunctionalArgument.kt"); + doTest(fileName); + } + + @TestMetadata("implicitInvokeWithFunctionLiteralArgument.kt") + public void testImplicitInvokeWithFunctionLiteralArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/functions/invoke/implicitInvokeWithFunctionLiteralArgument.kt"); + doTest(fileName); + } + @TestMetadata("invoke.kt") public void testInvoke() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/functions/invoke/invoke.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeCodegenTestGenerated.java index 0284afe4976..f4571ebb2e1 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeCodegenTestGenerated.java @@ -7744,6 +7744,18 @@ public class LightAnalysisModeCodegenTestGenerated extends AbstractLightAnalysis doTest(fileName); } + @TestMetadata("implicitInvokeInCompanionObjectWithFunctionalArgument.kt") + public void testImplicitInvokeInCompanionObjectWithFunctionalArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/functions/invoke/implicitInvokeInCompanionObjectWithFunctionalArgument.kt"); + doTest(fileName); + } + + @TestMetadata("implicitInvokeWithFunctionLiteralArgument.kt") + public void testImplicitInvokeWithFunctionLiteralArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/functions/invoke/implicitInvokeWithFunctionLiteralArgument.kt"); + doTest(fileName); + } + @TestMetadata("invoke.kt") public void testInvoke() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/functions/invoke/invoke.kt"); diff --git a/idea/tests/org/jetbrains/kotlin/idea/intentions/IntentionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/intentions/IntentionTestGenerated.java index 84e87bcbfe3..36704fcf13c 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/intentions/IntentionTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/intentions/IntentionTestGenerated.java @@ -1,5 +1,5 @@ /* - * Copyright 2010-2017 JetBrains s.r.o. + * Copyright 2010-2016 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixTestGenerated.java index 7f53fedfd43..4ff2f854575 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixTestGenerated.java @@ -1,5 +1,5 @@ /* - * Copyright 2010-2017 JetBrains s.r.o. + * Copyright 2010-2016 JetBrains s.r.o. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java index a66284162d0..7fd18dcf0ff 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java @@ -8825,6 +8825,18 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { doTest(fileName); } + @TestMetadata("implicitInvokeInCompanionObjectWithFunctionalArgument.kt") + public void testImplicitInvokeInCompanionObjectWithFunctionalArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/functions/invoke/implicitInvokeInCompanionObjectWithFunctionalArgument.kt"); + doTest(fileName); + } + + @TestMetadata("implicitInvokeWithFunctionLiteralArgument.kt") + public void testImplicitInvokeWithFunctionLiteralArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/functions/invoke/implicitInvokeWithFunctionLiteralArgument.kt"); + doTest(fileName); + } + @TestMetadata("invoke.kt") public void testInvoke() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/box/functions/invoke/invoke.kt");