diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt index 30238de76cc..60028d7ecc3 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt @@ -24,11 +24,13 @@ import org.jetbrains.kotlin.load.java.sam.JvmSamConversionTransformer import org.jetbrains.kotlin.load.java.sam.SamConversionResolverImpl import org.jetbrains.kotlin.resolve.PlatformConfigurator import org.jetbrains.kotlin.resolve.calls.checkers.ReifiedTypeParameterSubstitutionChecker +import org.jetbrains.kotlin.resolve.checkers.BigFunctionTypeAvailabilityChecker import org.jetbrains.kotlin.resolve.checkers.ExpectedActualDeclarationChecker import org.jetbrains.kotlin.resolve.jvm.* import org.jetbrains.kotlin.resolve.jvm.checkers.* import org.jetbrains.kotlin.synthetic.JavaSyntheticScopes import org.jetbrains.kotlin.types.DynamicTypesSettings +import org.jetbrains.kotlin.types.expressions.FunctionWithBigAritySupport object JvmPlatformConfigurator : PlatformConfigurator( DynamicTypesSettings(), @@ -67,6 +69,7 @@ object JvmPlatformConfigurator : PlatformConfigurator( ), additionalClassifierUsageCheckers = listOf( + BigFunctionTypeAvailabilityChecker ), additionalAnnotationCheckers = listOf( @@ -100,5 +103,6 @@ object JvmPlatformConfigurator : PlatformConfigurator( container.useInstance(JvmTypeSpecificityComparator) container.useImpl() container.useImpl() + container.useInstance(FunctionWithBigAritySupport.LANGUAGE_VERSION_DEPENDENT) } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/BigFunctionTypeAvailabilityChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/BigFunctionTypeAvailabilityChecker.kt new file mode 100644 index 00000000000..145109bf58f --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/BigFunctionTypeAvailabilityChecker.kt @@ -0,0 +1,30 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.resolve.checkers + +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor +import org.jetbrains.kotlin.config.LanguageFeature +import org.jetbrains.kotlin.descriptors.ClassifierDescriptor +import org.jetbrains.kotlin.diagnostics.Errors +import org.jetbrains.kotlin.types.typeUtil.contains + +object BigFunctionTypeAvailabilityChecker : ClassifierUsageChecker { + override fun check(targetDescriptor: ClassifierDescriptor, element: PsiElement, context: ClassifierUsageCheckerContext) { + if (context.languageVersionSettings.supportsFeature(LanguageFeature.FunctionTypesWithBigArity)) return + + if (targetDescriptor.defaultType.contains { argumentType -> + val descriptor = argumentType.constructor.declarationDescriptor + descriptor is FunctionClassDescriptor && descriptor.hasBigArity + }) { + context.trace.report( + Errors.UNSUPPORTED_FEATURE.on( + element, LanguageFeature.FunctionTypesWithBigArity to context.languageVersionSettings + ) + ) + } + } +} diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DoubleColonExpressionResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DoubleColonExpressionResolver.kt index b4a6628d8dd..5e52218772a 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DoubleColonExpressionResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/DoubleColonExpressionResolver.kt @@ -7,12 +7,15 @@ package org.jetbrains.kotlin.types.expressions import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.builtins.ReflectionTypes +import org.jetbrains.kotlin.builtins.functions.FunctionInvokeDescriptor import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.config.LanguageVersionSettings +import org.jetbrains.kotlin.container.DefaultImplementation import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor +import org.jetbrains.kotlin.diagnostics.Errors import org.jetbrains.kotlin.diagnostics.Errors.* import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.name.Name @@ -84,7 +87,8 @@ class DoubleColonExpressionResolver( val typeResolver: TypeResolver, val languageVersionSettings: LanguageVersionSettings, val additionalCheckers: Iterable, - val dataFlowValueFactory: DataFlowValueFactory + val dataFlowValueFactory: DataFlowValueFactory, + val bigAritySupport: FunctionWithBigAritySupport ) { private lateinit var expressionTypingServices: ExpressionTypingServices @@ -592,6 +596,15 @@ class DoubleColonExpressionResolver( ) context.trace.record(BindingContext.FUNCTION, expression, functionDescriptor) + + if (functionDescriptor.valueParameters.size >= FunctionInvokeDescriptor.BIG_ARITY && + bigAritySupport.shouldCheckLanguageVersionSettings && + !languageVersionSettings.supportsFeature(LanguageFeature.FunctionTypesWithBigArity) + ) { + context.trace.report(Errors.UNSUPPORTED_FEATURE.on( + expression, LanguageFeature.FunctionTypesWithBigArity to languageVersionSettings + )) + } } internal fun bindPropertyReference( @@ -796,3 +809,15 @@ class DoubleColonExpressionResolver( } } } + +// By default, function types with big arity are supported. On platforms where they are not supported by default (e.g. JVM), +// LANGUAGE_VERSION_DEPENDENT should be used which makes the code check if the corresponding language feature is enabled. +@DefaultImplementation(FunctionWithBigAritySupport::class) +class FunctionWithBigAritySupport private constructor(val shouldCheckLanguageVersionSettings: Boolean) { + constructor() : this(false) + + companion object { + @JvmField + val LANGUAGE_VERSION_DEPENDENT = FunctionWithBigAritySupport(true) + } +} diff --git a/compiler/testData/codegen/box/functions/bigArity/callWithIncorrectNumberOfArguments.kt b/compiler/testData/codegen/box/functions/bigArity/callWithIncorrectNumberOfArguments.kt index d882b078576..aa7464771aa 100644 --- a/compiler/testData/codegen/box/functions/bigArity/callWithIncorrectNumberOfArguments.kt +++ b/compiler/testData/codegen/box/functions/bigArity/callWithIncorrectNumberOfArguments.kt @@ -1,3 +1,4 @@ +// !LANGUAGE: +FunctionTypesWithBigArity // WITH_RUNTIME // TARGET_BACKEND: JVM // FILE: J.java diff --git a/compiler/testData/codegen/box/functions/bigArity/function255.kt b/compiler/testData/codegen/box/functions/bigArity/function255.kt index 2e064b0b24c..39c6066e8db 100644 --- a/compiler/testData/codegen/box/functions/bigArity/function255.kt +++ b/compiler/testData/codegen/box/functions/bigArity/function255.kt @@ -1,3 +1,4 @@ +// !LANGUAGE: +FunctionTypesWithBigArity // IGNORE_BACKEND: JS_IR class A(val value: Int) { diff --git a/compiler/testData/codegen/box/functions/bigArity/instanceOfCallableReference.kt b/compiler/testData/codegen/box/functions/bigArity/instanceOfCallableReference.kt index 4208ef4d759..4edd35350dc 100644 --- a/compiler/testData/codegen/box/functions/bigArity/instanceOfCallableReference.kt +++ b/compiler/testData/codegen/box/functions/bigArity/instanceOfCallableReference.kt @@ -1,3 +1,4 @@ +// !LANGUAGE: +FunctionTypesWithBigArity // IGNORE_BACKEND: JS_IR, JS class A diff --git a/compiler/testData/codegen/box/functions/bigArity/invokeCallableReference.kt b/compiler/testData/codegen/box/functions/bigArity/invokeCallableReference.kt index 14378b51686..c9509a07ba5 100644 --- a/compiler/testData/codegen/box/functions/bigArity/invokeCallableReference.kt +++ b/compiler/testData/codegen/box/functions/bigArity/invokeCallableReference.kt @@ -1,3 +1,5 @@ +// !LANGUAGE: +FunctionTypesWithBigArity + class A fun foo( diff --git a/compiler/testData/codegen/box/functions/bigArity/invokeLambda.kt b/compiler/testData/codegen/box/functions/bigArity/invokeLambda.kt index 8e016138c83..afb24c958db 100644 --- a/compiler/testData/codegen/box/functions/bigArity/invokeLambda.kt +++ b/compiler/testData/codegen/box/functions/bigArity/invokeLambda.kt @@ -1,3 +1,5 @@ +// !LANGUAGE: +FunctionTypesWithBigArity + class A(val value: Int) private fun check(actual: A, expected: Int) { diff --git a/compiler/testData/codegen/box/functions/bigArity/javaLambda.kt b/compiler/testData/codegen/box/functions/bigArity/javaLambda.kt index c44b2449dfc..fb8080cecb7 100644 --- a/compiler/testData/codegen/box/functions/bigArity/javaLambda.kt +++ b/compiler/testData/codegen/box/functions/bigArity/javaLambda.kt @@ -1,3 +1,4 @@ +// !LANGUAGE: +FunctionTypesWithBigArity // WITH_RUNTIME // TARGET_BACKEND: JVM // FILE: J.java diff --git a/compiler/testData/codegen/box/functions/bigArity/noBigFunctionTypes.kt b/compiler/testData/codegen/box/functions/bigArity/noBigFunctionTypes.kt new file mode 100644 index 00000000000..7910b3ceb1a --- /dev/null +++ b/compiler/testData/codegen/box/functions/bigArity/noBigFunctionTypes.kt @@ -0,0 +1,22 @@ +// !LANGUAGE: -FunctionTypesWithBigArity + +// This test does not make sense for JVM because a diagnostic is reported when function types with big arity are not available +// (see diagnostics/tests/sourceCompatibility/noBigFunctionTypes.kt) +// IGNORE_BACKEND: JVM + +class A + +fun foo( + p00: A, p01: A, p02: A, p03: A, p04: A, p05: A, p06: A, p07: A, p08: A, p09: A, + p10: A, p11: A, p12: A, p13: A, p14: A, p15: A, p16: A, p17: A, p18: A, p19: A, + p20: A, p21: A, p22: A, p23: A, p24: A, p25: A, p26: A, p27: A, p28: A, p29: A +): String = "OK" + +fun bar(x: Function30): String { + val a = A() + return x(a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a) +} + +fun box(): String { + return bar(::foo) +} diff --git a/compiler/testData/codegen/box/functions/bigArity/subclass.kt b/compiler/testData/codegen/box/functions/bigArity/subclass.kt index 31ca50c3e02..12c3de3993a 100644 --- a/compiler/testData/codegen/box/functions/bigArity/subclass.kt +++ b/compiler/testData/codegen/box/functions/bigArity/subclass.kt @@ -1,3 +1,5 @@ +// !LANGUAGE: +FunctionTypesWithBigArity + // Implementing function interface is prohibited in JavaScript // IGNORE_BACKEND: JS_IR, JS diff --git a/compiler/testData/codegen/box/javaInterop/notNullAssertions/functionWithBigArity.kt b/compiler/testData/codegen/box/javaInterop/notNullAssertions/functionWithBigArity.kt index ca7a4971aed..c70cacf2bd2 100644 --- a/compiler/testData/codegen/box/javaInterop/notNullAssertions/functionWithBigArity.kt +++ b/compiler/testData/codegen/box/javaInterop/notNullAssertions/functionWithBigArity.kt @@ -1,3 +1,4 @@ +// !LANGUAGE: +FunctionTypesWithBigArity // TARGET_BACKEND: JVM // WITH_RUNTIME // FILE: Test.java diff --git a/compiler/testData/codegen/box/reflection/call/bigArity.kt b/compiler/testData/codegen/box/reflection/call/bigArity.kt index cd275bd789e..43d32de4734 100644 --- a/compiler/testData/codegen/box/reflection/call/bigArity.kt +++ b/compiler/testData/codegen/box/reflection/call/bigArity.kt @@ -1,3 +1,4 @@ +// !LANGUAGE: +FunctionTypesWithBigArity // IGNORE_BACKEND: JS_IR, JS, NATIVE // WITH_REFLECT diff --git a/compiler/testData/codegen/box/reflection/parameters/bigArity.kt b/compiler/testData/codegen/box/reflection/parameters/bigArity.kt index a80ccd55e9a..c22d4cb175b 100644 --- a/compiler/testData/codegen/box/reflection/parameters/bigArity.kt +++ b/compiler/testData/codegen/box/reflection/parameters/bigArity.kt @@ -1,3 +1,4 @@ +// !LANGUAGE: +FunctionTypesWithBigArity // IGNORE_BACKEND: JS_IR, JS, NATIVE // WITH_REFLECT diff --git a/compiler/testData/diagnostics/tests/sourceCompatibility/noBigFunctionTypes.kt b/compiler/testData/diagnostics/tests/sourceCompatibility/noBigFunctionTypes.kt new file mode 100644 index 00000000000..3495385462a --- /dev/null +++ b/compiler/testData/diagnostics/tests/sourceCompatibility/noBigFunctionTypes.kt @@ -0,0 +1,17 @@ +// !LANGUAGE: -FunctionTypesWithBigArity +// !DIAGNOSTICS: -UNUSED_PARAMETER + +class A + +fun foo( + p00: A, p01: A, p02: A, p03: A, p04: A, p05: A, p06: A, p07: A, p08: A, p09: A, + p10: A, p11: A, p12: A, p13: A, p14: A, p15: A, p16: A, p17: A, p18: A, p19: A, + p20: A, p21: A, p22: A, p23: A, p24: A, p25: A, p26: A, p27: A, p28: A, p29: A +) {} + +fun bar(x: Any) {} + +fun test(vararg x: Function30<*, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, Unit>) { + bar(::foo) + bar(x) +} diff --git a/compiler/testData/diagnostics/tests/sourceCompatibility/noBigFunctionTypes.txt b/compiler/testData/diagnostics/tests/sourceCompatibility/noBigFunctionTypes.txt new file mode 100644 index 00000000000..68ed64937d3 --- /dev/null +++ b/compiler/testData/diagnostics/tests/sourceCompatibility/noBigFunctionTypes.txt @@ -0,0 +1,12 @@ +package + +public fun bar(/*0*/ x: kotlin.Any): kotlin.Unit +public fun foo(/*0*/ p00: A, /*1*/ p01: A, /*2*/ p02: A, /*3*/ p03: A, /*4*/ p04: A, /*5*/ p05: A, /*6*/ p06: A, /*7*/ p07: A, /*8*/ p08: A, /*9*/ p09: A, /*10*/ p10: A, /*11*/ p11: A, /*12*/ p12: A, /*13*/ p13: A, /*14*/ p14: A, /*15*/ p15: A, /*16*/ p16: A, /*17*/ p17: A, /*18*/ p18: A, /*19*/ p19: A, /*20*/ p20: A, /*21*/ p21: A, /*22*/ p22: A, /*23*/ p23: A, /*24*/ p24: A, /*25*/ p25: A, /*26*/ p26: A, /*27*/ p27: A, /*28*/ p28: A, /*29*/ p29: A): kotlin.Unit +public fun test(/*0*/ vararg x: kotlin.Function30<*, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, *, kotlin.Unit> /*kotlin.Array>*/): kotlin.Unit + +public final class A { + public constructor A() + 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/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 e06c195cf26..50912b39cea 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 @@ -10317,6 +10317,11 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes runTest("compiler/testData/codegen/box/functions/bigArity/javaLambda.kt"); } + @TestMetadata("noBigFunctionTypes.kt") + public void testNoBigFunctionTypes() throws Exception { + runTest("compiler/testData/codegen/box/functions/bigArity/noBigFunctionTypes.kt"); + } + @TestMetadata("subclass.kt") public void testSubclass() throws Exception { runTest("compiler/testData/codegen/box/functions/bigArity/subclass.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java index a43a2eab0e6..5ec350ead6e 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java @@ -20427,6 +20427,11 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest { runTest("compiler/testData/diagnostics/tests/sourceCompatibility/inlineFunctionAlways.kt"); } + @TestMetadata("noBigFunctionTypes.kt") + public void testNoBigFunctionTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/sourceCompatibility/noBigFunctionTypes.kt"); + } + @TestMetadata("noCallableReferencesWithEmptyLHS.kt") public void testNoCallableReferencesWithEmptyLHS() throws Exception { runTest("compiler/testData/diagnostics/tests/sourceCompatibility/noCallableReferencesWithEmptyLHS.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java index 3356f585411..6a102355c1a 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java @@ -20427,6 +20427,11 @@ public class DiagnosticsUsingJavacTestGenerated extends AbstractDiagnosticsUsing runTest("compiler/testData/diagnostics/tests/sourceCompatibility/inlineFunctionAlways.kt"); } + @TestMetadata("noBigFunctionTypes.kt") + public void testNoBigFunctionTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/sourceCompatibility/noBigFunctionTypes.kt"); + } + @TestMetadata("noCallableReferencesWithEmptyLHS.kt") public void testNoCallableReferencesWithEmptyLHS() throws Exception { runTest("compiler/testData/diagnostics/tests/sourceCompatibility/noCallableReferencesWithEmptyLHS.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java index 16f182ab1ed..bebf00dfdeb 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java @@ -10317,6 +10317,11 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { runTest("compiler/testData/codegen/box/functions/bigArity/javaLambda.kt"); } + @TestMetadata("noBigFunctionTypes.kt") + public void testNoBigFunctionTypes() throws Exception { + runTest("compiler/testData/codegen/box/functions/bigArity/noBigFunctionTypes.kt"); + } + @TestMetadata("subclass.kt") public void testSubclass() throws Exception { runTest("compiler/testData/codegen/box/functions/bigArity/subclass.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java index ac7be3b9a24..6515a01ba57 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -10279,6 +10279,11 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) public static class BigArity extends AbstractLightAnalysisModeTest { + @TestMetadata("noBigFunctionTypes.kt") + public void ignoreNoBigFunctionTypes() throws Exception { + runTest("compiler/testData/codegen/box/functions/bigArity/noBigFunctionTypes.kt"); + } + private void runTest(String testDataFilePath) throws Exception { KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM, testDataFilePath); } diff --git a/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt b/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt index 72f4f77e69d..566060bf35f 100644 --- a/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt +++ b/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt @@ -78,6 +78,7 @@ enum class LanguageFeature( ProhibitSmartcastsOnLocalDelegatedProperty(KOTLIN_1_3, kind = BUG_FIX), ProhibitOperatorMod(KOTLIN_1_3, kind = BUG_FIX), ProhibitAssigningSingleElementsToVarargsInNamedForm(KOTLIN_1_3, kind = BUG_FIX), + FunctionTypesWithBigArity(KOTLIN_1_3, sinceApiVersion = ApiVersion.KOTLIN_1_3), StrictJavaNullabilityAssertions(sinceVersion = null, defaultState = State.DISABLED), ProperIeee754Comparisons(sinceVersion = null, defaultState = State.DISABLED), diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt index e3720d45f77..09c8d7fdc35 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt @@ -73,6 +73,10 @@ class FunctionClassDescriptor( parameters = result.toList() } + @get:JvmName("hasBigArity") + val hasBigArity: Boolean + get() = arity >= FunctionInvokeDescriptor.BIG_ARITY + override fun getContainingDeclaration() = containingDeclaration override fun getStaticScope() = MemberScope.Empty diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/IrJsCodegenBoxTestGenerated.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/IrJsCodegenBoxTestGenerated.java index 1bfc25204be..cbca4aff8f0 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/IrJsCodegenBoxTestGenerated.java +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/IrJsCodegenBoxTestGenerated.java @@ -8967,6 +8967,11 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { runTest("compiler/testData/codegen/box/functions/bigArity/invokeLambda.kt"); } + @TestMetadata("noBigFunctionTypes.kt") + public void testNoBigFunctionTypes() throws Exception { + runTest("compiler/testData/codegen/box/functions/bigArity/noBigFunctionTypes.kt"); + } + @TestMetadata("subclass.kt") public void testSubclass() throws Exception { runTest("compiler/testData/codegen/box/functions/bigArity/subclass.kt"); 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 588c3fa6704..9d27079968a 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 @@ -9962,6 +9962,11 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { runTest("compiler/testData/codegen/box/functions/bigArity/invokeLambda.kt"); } + @TestMetadata("noBigFunctionTypes.kt") + public void testNoBigFunctionTypes() throws Exception { + runTest("compiler/testData/codegen/box/functions/bigArity/noBigFunctionTypes.kt"); + } + @TestMetadata("subclass.kt") public void testSubclass() throws Exception { runTest("compiler/testData/codegen/box/functions/bigArity/subclass.kt");