From cf5c5dba3dc602aa91b9be68fdc2a00b494d9aeb Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Thu, 4 Jul 2013 14:14:35 +0400 Subject: [PATCH] KT-3189 Function invoke is called with no reason prioritize tasks specially for invoke #KT-3189 Fixed #KT-3190 Fixed #KT-3297 Fixed --- .../resolve/calls/tasks/TaskPrioritizer.java | 246 +++++++++++++----- .../box/functions/{ => invoke}/invoke.kt | 0 .../codegen/box/functions/invoke/kt3189.kt | 15 ++ .../codegen/box/functions/invoke/kt3190.kt | 24 ++ .../codegen/box/functions/invoke/kt3297.kt | 17 ++ .../tests/resolve/invoke/invokeAsExtension.kt | 63 +++++ .../tests/resolve/invoke/invokeAsMember.kt | 62 +++++ .../resolve/invoke/invokeAsMemberExtension.kt | 125 +++++++++ ...vokeAsMemberExtensionToExplicitReceiver.kt | 12 + .../checkers/JetDiagnosticsTestGenerated.java | 37 ++- .../BlackBoxCodegenTestGenerated.java | 36 ++- 11 files changed, 567 insertions(+), 70 deletions(-) rename compiler/testData/codegen/box/functions/{ => invoke}/invoke.kt (100%) create mode 100644 compiler/testData/codegen/box/functions/invoke/kt3189.kt create mode 100644 compiler/testData/codegen/box/functions/invoke/kt3190.kt create mode 100644 compiler/testData/codegen/box/functions/invoke/kt3297.kt create mode 100644 compiler/testData/diagnostics/tests/resolve/invoke/invokeAsExtension.kt create mode 100644 compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMember.kt create mode 100644 compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMemberExtension.kt create mode 100644 compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMemberExtensionToExplicitReceiver.kt diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java index 908c9d2ea68..e2d2788afc7 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java @@ -75,8 +75,12 @@ public class TaskPrioritizer { } @NotNull - public static List> computePrioritizedTasks(@NotNull final BasicCallResolutionContext context, @NotNull Name name, - @NotNull JetReferenceExpression functionReference, @NotNull List> callableDescriptorCollectors) { + public static List> computePrioritizedTasks( + @NotNull BasicCallResolutionContext context, + @NotNull Name name, + @NotNull JetReferenceExpression functionReference, + @NotNull List> callableDescriptorCollectors + ) { ReceiverValue explicitReceiver = context.call.getExplicitReceiver(); JetScope scope; if (explicitReceiver.exists() && explicitReceiver.getType() instanceof NamespaceType) { @@ -89,88 +93,176 @@ public class TaskPrioritizer { } ResolutionTaskHolder result = new ResolutionTaskHolder(functionReference, context, new MyPriorityProvider(context)); - doComputeTasks(scope, explicitReceiver, name, result, context, callableDescriptorCollectors); + TaskPrioritizerContext c = new TaskPrioritizerContext(name, result, context, scope, callableDescriptorCollectors); + doComputeTasks(explicitReceiver, c); return result.getTasks(); } private static void doComputeTasks( - @NotNull JetScope scope, @NotNull ReceiverValue receiver, - @NotNull Name name, @NotNull ResolutionTaskHolder result, - @NotNull BasicCallResolutionContext context, - @NotNull List> callableDescriptorCollectors + @NotNull ReceiverValue receiver, + @NotNull TaskPrioritizerContext c ) { ProgressIndicatorProvider.checkCanceled(); - AutoCastServiceImpl autoCastService = new AutoCastServiceImpl(context.dataFlowInfo, context.trace.getBindingContext()); - List implicitReceivers = JetScopeUtils.getImplicitReceiversHierarchyValues(scope); - boolean hasExplicitThisObject = context.call.getThisObject().exists(); - if (hasExplicitThisObject) { - implicitReceivers.add(context.call.getThisObject()); + boolean resolveInvoke = c.context.call.getThisObject().exists(); + if (resolveInvoke) { + addCandidatesForInvoke(receiver, c); + return; } + List implicitReceivers = JetScopeUtils.getImplicitReceiversHierarchyValues(c.scope); if (receiver.exists()) { - List variantsForExplicitReceiver = autoCastService.getVariantsForReceiver(receiver); - - for (CallableDescriptorCollector callableDescriptorCollector : callableDescriptorCollectors) { - Collection> members = Lists.newArrayList(); - for (ReceiverValue variant : variantsForExplicitReceiver) { - Collection membersForThisVariant = callableDescriptorCollector.getMembersByName(variant.getType(), name); - convertWithReceivers(membersForThisVariant, Collections.singletonList(variant), - Collections.singletonList(NO_RECEIVER), members, hasExplicitThisObject); - } - result.addCandidates(members); - } - - for (CallableDescriptorCollector callableDescriptorCollector : callableDescriptorCollectors) { - for (ReceiverValue implicitReceiver : implicitReceivers) { - Collection memberExtensions = callableDescriptorCollector.getNonMembersByName( - implicitReceiver.getType().getMemberScope(), name); - List variantsForImplicitReceiver = autoCastService.getVariantsForReceiver(implicitReceiver); - result.addCandidates(convertWithReceivers(memberExtensions, variantsForImplicitReceiver, - variantsForExplicitReceiver, hasExplicitThisObject)); - } - Collection> extensionFunctions = convertWithImpliedThis( - scope, variantsForExplicitReceiver, callableDescriptorCollector.getNonMembersByName(scope, name)); - result.addCandidates(extensionFunctions); - } + addCandidatesForExplicitReceiver(receiver, implicitReceivers, c, /*resolveInvoke=*/false); + return; } - else { - List>> localsList = Lists.newArrayList(); - List>> nonlocalsList = Lists.newArrayList(); - for (CallableDescriptorCollector callableDescriptorCollector : callableDescriptorCollectors) { + addCandidatesForNoReceiver(implicitReceivers, c); + } - Collection> functions = - convertWithImpliedThis(scope, Collections.singletonList(receiver), callableDescriptorCollector - .getNonExtensionsByName(scope, name)); + private static void addCandidatesForExplicitReceiver( + @NotNull ReceiverValue receiver, + @NotNull List implicitReceivers, + @NotNull TaskPrioritizerContext c, + boolean resolveInvoke + ) { - List> nonlocals = Lists.newArrayList(); - List> locals = Lists.newArrayList(); - //noinspection unchecked,RedundantTypeArguments - TaskPrioritizer.splitLexicallyLocalDescriptors(functions, scope.getContainingDeclaration(), locals, nonlocals); + List variantsForExplicitReceiver = c.autoCastService.getVariantsForReceiver(receiver); - localsList.add(locals); - nonlocalsList.add(nonlocals); + //members + for (CallableDescriptorCollector callableDescriptorCollector : c.callableDescriptorCollectors) { + Collection> members = Lists.newArrayList(); + for (ReceiverValue variant : variantsForExplicitReceiver) { + Collection membersForThisVariant = callableDescriptorCollector.getMembersByName(variant.getType(), c.name); + convertWithReceivers(membersForThisVariant, Collections.singletonList(variant), + Collections.singletonList(NO_RECEIVER), members, resolveInvoke); } + c.result.addCandidates(members); + } - result.addCandidates(localsList); - + for (CallableDescriptorCollector callableDescriptorCollector : c.callableDescriptorCollectors) { + //member extensions for (ReceiverValue implicitReceiver : implicitReceivers) { - doComputeTasks(scope, implicitReceiver, name, result, context, callableDescriptorCollectors); + addMemberExtensionCandidates(implicitReceiver, variantsForExplicitReceiver, + callableDescriptorCollector, c, resolveInvoke); } - result.addCandidates(nonlocalsList); + //extensions + Collection> extensionFunctions = convertWithImpliedThis( + c.scope, variantsForExplicitReceiver, callableDescriptorCollector.getNonMembersByName(c.scope, c.name)); + c.result.addCandidates(extensionFunctions); } } - private static Collection> convertWithReceivers(Collection descriptors, Iterable thisObjects, - Iterable receiverParameters, boolean hasExplicitThisObject) { + private static void addMemberExtensionCandidates( + @NotNull ReceiverValue implicitReceiver, + @NotNull List variantsForExplicitReceiver, + @NotNull CallableDescriptorCollector callableDescriptorCollector, TaskPrioritizerContext c, + boolean resolveInvoke + ) { + Collection memberExtensions = callableDescriptorCollector.getNonMembersByName( + implicitReceiver.getType().getMemberScope(), c.name); + List variantsForImplicitReceiver = c.autoCastService.getVariantsForReceiver(implicitReceiver); + c.result.addCandidates(convertWithReceivers(memberExtensions, variantsForImplicitReceiver, + variantsForExplicitReceiver, resolveInvoke)); + } + private static void addCandidatesForNoReceiver( + @NotNull List implicitReceivers, + @NotNull TaskPrioritizerContext c + ) { + List>> localsList = Lists.newArrayList(); + List>> nonlocalsList = Lists.newArrayList(); + for (CallableDescriptorCollector callableDescriptorCollector : c.callableDescriptorCollectors) { + + Collection> functions = + convertWithImpliedThis(c.scope, Collections.singletonList(NO_RECEIVER), callableDescriptorCollector + .getNonExtensionsByName(c.scope, c.name)); + + List> nonlocals = Lists.newArrayList(); + List> locals = Lists.newArrayList(); + //noinspection unchecked,RedundantTypeArguments + TaskPrioritizer.splitLexicallyLocalDescriptors(functions, c.scope.getContainingDeclaration(), locals, nonlocals); + + localsList.add(locals); + nonlocalsList.add(nonlocals); + } + + //locals + c.result.addCandidates(localsList); + + //try all implicit receivers as explicit + for (ReceiverValue implicitReceiver : implicitReceivers) { + addCandidatesForExplicitReceiver(implicitReceiver, implicitReceivers, c, /*resolveInvoke=*/false); + } + + //nonlocals + c.result.addCandidates(nonlocalsList); + } + + private static void addCandidatesForInvoke( + @NotNull ReceiverValue explicitReceiver, + @NotNull TaskPrioritizerContext c + ) { + List implicitReceivers = JetScopeUtils.getImplicitReceiversHierarchyValues(c.scope); + + // For 'a.foo()' where foo has function type, + // a is explicitReceiver, foo is variableReceiver. + ReceiverValue variableReceiver = c.context.call.getThisObject(); + assert variableReceiver.exists() : "'Invoke' call hasn't got variable receiver"; + + // For invocation a.foo() explicit receiver 'a' + // can be a receiver for 'foo' variable + // or for 'invoke' function. + + // (1) a.foo + foo.invoke() + if (!explicitReceiver.exists()) { + addCandidatesForExplicitReceiver(variableReceiver, implicitReceivers, c, /*resolveInvoke=*/true); + } + + // (2) foo + a.invoke() + + // 'invoke' is member extension to explicit receiver while variable receiver is 'this object' + //trait A + //trait Foo { fun A.invoke() } + + if (explicitReceiver.exists()) { + //a.foo() + addCandidatesWhenInvokeIsMemberExtensionToExplicitReceiver(variableReceiver, explicitReceiver, c); + return; + } + // with (a) { foo() } + for (ReceiverValue implicitReceiver : implicitReceivers) { + addCandidatesWhenInvokeIsMemberExtensionToExplicitReceiver(variableReceiver, implicitReceiver, c); + } + } + + private static void addCandidatesWhenInvokeIsMemberExtensionToExplicitReceiver( + @NotNull ReceiverValue variableReceiver, + @NotNull ReceiverValue explicitReceiver, + @NotNull TaskPrioritizerContext c + ) { + List variantsForExplicitReceiver = c.autoCastService.getVariantsForReceiver(explicitReceiver); + + for (CallableDescriptorCollector callableDescriptorCollector : c.callableDescriptorCollectors) { + addMemberExtensionCandidates(variableReceiver, variantsForExplicitReceiver, callableDescriptorCollector, c, /*resolveInvoke=*/true); + } + } + + private static Collection> convertWithReceivers( + @NotNull Collection descriptors, + @NotNull Iterable thisObjects, + @NotNull Iterable receiverParameters, + boolean hasExplicitThisObject + ) { Collection> result = Lists.newArrayList(); convertWithReceivers(descriptors, thisObjects, receiverParameters, result, hasExplicitThisObject); return result; } - private static void convertWithReceivers(Collection descriptors, Iterable thisObjects, Iterable receiverParameters, - Collection> result, boolean hasExplicitThisObject) { - + private static void convertWithReceivers( + @NotNull Collection descriptors, + @NotNull Iterable thisObjects, + @NotNull Iterable receiverParameters, + @NotNull Collection> result, + boolean hasExplicitThisObject + ) { for (ReceiverValue thisObject : thisObjects) { for (ReceiverValue receiverParameter : receiverParameters) { for (D extension : descriptors) { @@ -189,7 +281,11 @@ public class TaskPrioritizer { } } - public static Collection> convertWithImpliedThis(JetScope scope, Collection receiverParameters, Collection descriptors) { + public static Collection> convertWithImpliedThis( + @NotNull JetScope scope, + @NotNull Collection receiverParameters, + @NotNull Collection descriptors + ) { Collection> result = Lists.newArrayList(); for (ReceiverValue receiverParameter : receiverParameters) { for (D descriptor : descriptors) { @@ -221,7 +317,10 @@ public class TaskPrioritizer { return result; } - private static boolean setImpliedThis(@NotNull JetScope scope, ResolutionCandidate candidate) { + private static boolean setImpliedThis( + @NotNull JetScope scope, + @NotNull ResolutionCandidate candidate + ) { ReceiverParameterDescriptor expectedThisObject = candidate.getDescriptor().getExpectedThisObject(); if (expectedThisObject == null) return true; List receivers = scope.getImplicitReceiversHierarchy(); @@ -245,9 +344,6 @@ public class TaskPrioritizer { return result.getTasks(); } - private TaskPrioritizer() { - } - private static class MyPriorityProvider implements ResolutionTaskHolder.PriorityProvider> { private final BasicCallResolutionContext context; @@ -279,4 +375,28 @@ public class TaskPrioritizer { isOrOverridesSynthesized((CallableMemberDescriptor) descriptor); } } + + private static class TaskPrioritizerContext { + @NotNull public final Name name; + @NotNull public final ResolutionTaskHolder result; + @NotNull public final BasicCallResolutionContext context; + @NotNull public final JetScope scope; + @NotNull public final List> callableDescriptorCollectors; + @NotNull AutoCastServiceImpl autoCastService; + + private TaskPrioritizerContext( + @NotNull Name name, + @NotNull ResolutionTaskHolder result, + @NotNull BasicCallResolutionContext context, + @NotNull JetScope scope, + @NotNull List> callableDescriptorCollectors + ) { + this.name = name; + this.result = result; + this.context = context; + this.scope = scope; + this.callableDescriptorCollectors = callableDescriptorCollectors; + autoCastService = new AutoCastServiceImpl(context.dataFlowInfo, context.trace.getBindingContext()); + } + } } diff --git a/compiler/testData/codegen/box/functions/invoke.kt b/compiler/testData/codegen/box/functions/invoke/invoke.kt similarity index 100% rename from compiler/testData/codegen/box/functions/invoke.kt rename to compiler/testData/codegen/box/functions/invoke/invoke.kt diff --git a/compiler/testData/codegen/box/functions/invoke/kt3189.kt b/compiler/testData/codegen/box/functions/invoke/kt3189.kt new file mode 100644 index 00000000000..149606d0e51 --- /dev/null +++ b/compiler/testData/codegen/box/functions/invoke/kt3189.kt @@ -0,0 +1,15 @@ +//KT-3189 Function invoke is called with no reason + +fun box(): String { + + val bad = Bad({ 1 }) + + return if (bad.test() == 1) "OK" else "fail" +} + +class Bad(val a: () -> Int) { + + fun test(): Int = a() + + fun invoke(): Int = 2 +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/functions/invoke/kt3190.kt b/compiler/testData/codegen/box/functions/invoke/kt3190.kt new file mode 100644 index 00000000000..b0eb6d488be --- /dev/null +++ b/compiler/testData/codegen/box/functions/invoke/kt3190.kt @@ -0,0 +1,24 @@ +//KT-3190 Compiler crash if function called 'invoke' calls a closure + +fun box(): String { + val test = Cached({ it + 2 }) + return if (test(1) == 3) "OK" else "fail" +} + +class Cached(private val generate: (K)->V): jet.Function1 { + val store = java.util.HashMap() + + // Everything works just fine if 'invoke' method is renamed to, for example, 'get' + override fun invoke(p1: K) = store.getOrPut(p1) { generate(p1) } +} + +//from library +fun MutableMap.getOrPut(key: K, defaultValue: ()-> V) : V { + if (this.containsKey(key)) { + return this.get(key) as V + } else { + val answer = defaultValue() + this.put(key, answer) + return answer + } +} diff --git a/compiler/testData/codegen/box/functions/invoke/kt3297.kt b/compiler/testData/codegen/box/functions/invoke/kt3297.kt new file mode 100644 index 00000000000..bfa9d55a77a --- /dev/null +++ b/compiler/testData/codegen/box/functions/invoke/kt3297.kt @@ -0,0 +1,17 @@ +//KT-3297 Calling the wrong function inside an extension method to the Function0 class + +fun Function0.or(alt: () -> R): R { + try { + return this() + } catch (e: Exception) { + return alt() + } +} + +fun box(): String { + return { + throw RuntimeException("fail") + } or { + "OK" + } +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/invokeAsExtension.kt b/compiler/testData/diagnostics/tests/resolve/invoke/invokeAsExtension.kt new file mode 100644 index 00000000000..f04620b96b6 --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/invoke/invokeAsExtension.kt @@ -0,0 +1,63 @@ +class Foo {} + +fun Foo.invoke() {} + +//no variable +fun test(foo: Foo) { + foo() +} + +//variable as member +trait A { + val foo: Foo +} + + +fun test(a: A) { + a.foo() + + with (a) { + foo() + } +} + +//variable as extension +trait B { +} +val B.foo = Foo() + +fun test(b: B) { + b.foo() + + with (b) { + foo() + } +} + +//variable as member extension +trait C + +trait D { + val C.foo: Foo + + fun test(c: C) { + c.foo() + + with (c) { + foo() + } + } +} + +fun test(d: D, c: C) { + with (d) { + c.foo() + + with (c) { + foo() + } + } +} + +//-------------- +fun with(receiver: T, f: T.() -> R) : R = receiver.f() \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMember.kt b/compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMember.kt new file mode 100644 index 00000000000..44c8084cbeb --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMember.kt @@ -0,0 +1,62 @@ +class Foo { + fun invoke() {} +} + +//no variable +fun test(foo: Foo) { + foo() +} + +//variable as member +trait A { + val foo: Foo +} + +fun test(a: A) { + a.foo() + + with (a) { + foo() + } +} + +//variable as extension +trait B {} +val B.foo = Foo() + + +fun test(b: B) { + b.foo() + + with (b) { + foo() + } +} + +//variable as member extension +trait C + +trait D { + val C.foo: Foo + + fun test(c: C) { + c.foo() + + with (c) { + foo() + } + } +} + +fun test(d: D, c: C) { + with (d) { + c.foo() + + with (c) { + foo() + } + } +} + +//-------------- +fun with(receiver: T, f: T.() -> R) : R = receiver.f() \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMemberExtension.kt b/compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMemberExtension.kt new file mode 100644 index 00000000000..2f312de73c8 --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMemberExtension.kt @@ -0,0 +1,125 @@ +class Foo + +//no variable +trait A { + fun Foo.invoke() {} + + fun test(foo: Foo) { + foo() + } +} + +//variable as member +trait B { + val foo: Foo +} + +class C { + fun Foo.invoke() {} + + fun test(b: B) { + b.foo() + + with (b) { + foo() + } + } +} + +fun test(c: C, b: B) { + with (c) { + b.foo() + + with (b) { + foo() + } + } +} + + +//variable as extension, +trait D { +} +val D.foo = Foo() + +class E { + fun Foo.invoke() {} + + fun test(d: D) { + d.foo() + + with (d) { + foo() + } + } +} + +fun test(e: E, d: D) { + with (e) { + d.foo() + + with (d) { + foo() + } + } +} + +//variable as member extension +trait F + +trait G { + val F.foo: Foo + fun Foo.invoke() + + fun test(f: F) { + f.foo() + + with (f) { + foo() + } + } +} + +fun test(g: G, f: F) { + with (g) { + f.foo() + + with (f) { + foo() + } + } +} + +//variable as member extension (2) +trait X + +trait U { + val X.foo: Foo +} + +trait V { + fun Foo.invoke() {} + + fun U.test(x: X) { + x.foo() + + with (x) { + foo() + } + } +} + +fun test(u: U, v: V, x: X) { + with (v) { + with (u) { + x.foo() + + with (x) { + foo() + } + } + } +} + +//-------------- +fun with(receiver: T, f: T.() -> R) : R = receiver.f() \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMemberExtensionToExplicitReceiver.kt b/compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMemberExtensionToExplicitReceiver.kt new file mode 100644 index 00000000000..1d75d9a9f40 --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMemberExtensionToExplicitReceiver.kt @@ -0,0 +1,12 @@ +trait A +trait Foo { + fun A.invoke() +} + +fun test(a: A, foo: Foo) { + a.foo() +} + +fun test(a: Int, foo: Int.()->Unit) { + a.foo() +} \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java index 3088039f8df..2bbd81a66cc 100644 --- a/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java @@ -4510,6 +4510,7 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage } @TestMetadata("compiler/testData/diagnostics/tests/resolve") + @InnerTestClasses({Resolve.Invoke.class}) public static class Resolve extends AbstractDiagnosticsTestWithEagerResolve { public void testAllFilesPresentInResolve() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/diagnostics/tests/resolve"), Pattern.compile("^(.+)\\.kt$"), true); @@ -4545,6 +4546,40 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage doTest("compiler/testData/diagnostics/tests/resolve/resolveWithoutGenerics.kt"); } + @TestMetadata("compiler/testData/diagnostics/tests/resolve/invoke") + public static class Invoke extends AbstractDiagnosticsTestWithEagerResolve { + public void testAllFilesPresentInInvoke() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/diagnostics/tests/resolve/invoke"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("invokeAsExtension.kt") + public void testInvokeAsExtension() throws Exception { + doTest("compiler/testData/diagnostics/tests/resolve/invoke/invokeAsExtension.kt"); + } + + @TestMetadata("invokeAsMember.kt") + public void testInvokeAsMember() throws Exception { + doTest("compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMember.kt"); + } + + @TestMetadata("invokeAsMemberExtension.kt") + public void testInvokeAsMemberExtension() throws Exception { + doTest("compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMemberExtension.kt"); + } + + @TestMetadata("invokeAsMemberExtensionToExplicitReceiver.kt") + public void testInvokeAsMemberExtensionToExplicitReceiver() throws Exception { + doTest("compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMemberExtensionToExplicitReceiver.kt"); + } + + } + + public static Test innerSuite() { + TestSuite suite = new TestSuite("Resolve"); + suite.addTestSuite(Resolve.class); + suite.addTestSuite(Invoke.class); + return suite; + } } @TestMetadata("compiler/testData/diagnostics/tests/scopes") @@ -5087,7 +5122,7 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage suite.addTestSuite(Recovery.class); suite.addTestSuite(Redeclarations.class); suite.addTestSuite(Regressions.class); - suite.addTestSuite(Resolve.class); + suite.addTest(Resolve.innerSuite()); suite.addTestSuite(Scopes.class); suite.addTestSuite(SenselessComparison.class); suite.addTestSuite(Shadowing.class); diff --git a/compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxCodegenTestGenerated.java index 34ba0c8f1f2..a11f85b39c7 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/codegen/generated/BlackBoxCodegenTestGenerated.java @@ -2092,7 +2092,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } @TestMetadata("compiler/testData/codegen/box/functions") - @InnerTestClasses({Functions.LocalFunctions.class}) + @InnerTestClasses({Functions.Invoke.class, Functions.LocalFunctions.class}) public static class Functions extends AbstractBlackBoxCodegenTest { public void testAllFilesPresentInFunctions() throws Exception { JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/codegen/box/functions"), Pattern.compile("^(.+)\\.kt$"), true); @@ -2168,11 +2168,6 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { doTest("compiler/testData/codegen/box/functions/functionNtoString.kt"); } - @TestMetadata("invoke.kt") - public void testInvoke() throws Exception { - doTest("compiler/testData/codegen/box/functions/invoke.kt"); - } - @TestMetadata("kt1038.kt") public void testKt1038() throws Exception { doTest("compiler/testData/codegen/box/functions/kt1038.kt"); @@ -2268,6 +2263,34 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { doTest("compiler/testData/codegen/box/functions/nothisnoclosure.kt"); } + @TestMetadata("compiler/testData/codegen/box/functions/invoke") + public static class Invoke extends AbstractBlackBoxCodegenTest { + public void testAllFilesPresentInInvoke() throws Exception { + JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/codegen/box/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("invoke.kt") + public void testInvoke() throws Exception { + doTest("compiler/testData/codegen/box/functions/invoke/invoke.kt"); + } + + @TestMetadata("kt3189.kt") + public void testKt3189() throws Exception { + doTest("compiler/testData/codegen/box/functions/invoke/kt3189.kt"); + } + + @TestMetadata("kt3190.kt") + public void testKt3190() throws Exception { + doTest("compiler/testData/codegen/box/functions/invoke/kt3190.kt"); + } + + @TestMetadata("kt3297.kt") + public void testKt3297() throws Exception { + doTest("compiler/testData/codegen/box/functions/invoke/kt3297.kt"); + } + + } + @TestMetadata("compiler/testData/codegen/box/functions/localFunctions") public static class LocalFunctions extends AbstractBlackBoxCodegenTest { public void testAllFilesPresentInLocalFunctions() throws Exception { @@ -2284,6 +2307,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { public static Test innerSuite() { TestSuite suite = new TestSuite("Functions"); suite.addTestSuite(Functions.class); + suite.addTestSuite(Invoke.class); suite.addTestSuite(LocalFunctions.class); return suite; }