Add diagnostics for default lambda inlining

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java

@@ -70,6 +70,7 @@ import static org.jetbrains.kotlin.codegen.AsmUtil.getMethodAsmFlags;
 import static org.jetbrains.kotlin.codegen.AsmUtil.isPrimitive;
 import static org.jetbrains.kotlin.codegen.inline.InlineCodegenUtil.*;
 import static org.jetbrains.kotlin.descriptors.annotations.AnnotationUtilKt.isInlineOnly;
+import static org.jetbrains.kotlin.resolve.inline.InlineUtil.isInlinableParameterExpression;
 import static org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils.isFunctionLiteral;
 
 public class InlineCodegen extends CallGenerator {
@@ -783,12 +784,6 @@ public class InlineCodegen extends CallGenerator {
                isInlinableParameterExpression(deparenthesized);
     }
 
-    private static boolean isInlinableParameterExpression(@Nullable KtExpression deparenthesized) {
-        return deparenthesized instanceof KtLambdaExpression ||
-               deparenthesized instanceof KtNamedFunction ||
-               deparenthesized instanceof KtCallableReferenceExpression;
-    }
-
     private LambdaInfo rememberClosure(@NotNull KtExpression expression, @NotNull Type type, @NotNull ValueParameterDescriptor parameter) {
         KtExpression lambda = KtPsiUtil.deparenthesize(expression);
         assert isInlinableParameterExpression(lambda) : "Couldn't find inline expression in " + expression.getText();

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java

@@ -926,7 +926,7 @@ public interface Errors {
     DiagnosticFactory0<KtDeclaration> INLINE_PROPERTY_WITH_BACKING_FIELD = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
     DiagnosticFactory0<KtAnnotationEntry> NON_INTERNAL_PUBLISHED_API = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory1<PsiElement, CallableDescriptor> PROTECTED_CALL_FROM_PUBLIC_INLINE = DiagnosticFactory1.create(WARNING);
-
+    DiagnosticFactory2<KtElement, KtExpression, DeclarationDescriptor> INVALID_DEFAULT_FUNCTIONAL_PARAMETER_FOR_INLINE = DiagnosticFactory2.create(ERROR);
 
     DiagnosticFactory0<PsiElement> NON_LOCAL_SUSPENSION_POINT = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory1<PsiElement, CallableDescriptor> ILLEGAL_SUSPEND_FUNCTION_CALL = DiagnosticFactory1.create(ERROR);

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java

@@ -836,6 +836,7 @@ public class DefaultErrorMessages {
         MAP.put(INLINE_PROPERTY_WITH_BACKING_FIELD, "Inline property cannot have backing field");
         MAP.put(NON_INTERNAL_PUBLISHED_API, "@PublishedApi annotation is only applicable for internal declaration");
         MAP.put(PROTECTED_CALL_FROM_PUBLIC_INLINE, "Protected function call from public-API inline function is deprecated", NAME);
+        MAP.put(INVALID_DEFAULT_FUNCTIONAL_PARAMETER_FOR_INLINE, "Invalid default value for inline parameter: ''{0}''. Only lambdas, anonymous functions, and callable references are supported", ELEMENT_TEXT, SHORT_NAMES_IN_TYPES);
         //Inline non locals
         MAP.put(NON_LOCAL_RETURN_NOT_ALLOWED, "Can''t inline ''{0}'' here: it may contain non-local returns. Add ''crossinline'' modifier to parameter declaration ''{0}''", ELEMENT_TEXT);
         MAP.put(INLINE_CALL_CYCLE, "The ''{0}'' invocation is a part of inline cycle", NAME);

compiler/frontend/src/org/jetbrains/kotlin/resolve/AnalyzerExtensions.java

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.resolve;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.config.LanguageVersionSettings;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.psi.KtCallableDeclaration;
 import org.jetbrains.kotlin.psi.KtNamedFunction;
@@ -37,10 +38,16 @@ public class AnalyzerExtensions {
 
     @NotNull private final BindingTrace trace;
     @NotNull private final Iterable<ReasonableInlineRule> reasonableInlineRules;
+    private LanguageVersionSettings languageVersionSettings;
 
-    public AnalyzerExtensions(@NotNull BindingTrace trace, @NotNull Iterable<ReasonableInlineRule> reasonableInlineRules) {
+    public AnalyzerExtensions(
+            @NotNull BindingTrace trace,
+            @NotNull Iterable<ReasonableInlineRule> reasonableInlineRules,
+            @NotNull LanguageVersionSettings languageVersionSettings
+    ) {
         this.trace = trace;
         this.reasonableInlineRules = reasonableInlineRules;
+        this.languageVersionSettings = languageVersionSettings;
     }
 
     public void process(@NotNull BodiesResolveContext bodiesResolveContext) {
@@ -66,7 +73,7 @@ public class AnalyzerExtensions {
     @NotNull
     private List<InlineAnalyzerExtension> getFunctionExtensions(@NotNull FunctionDescriptor functionDescriptor) {
         if (InlineUtil.isInline(functionDescriptor)) {
-            return Collections.singletonList(new InlineAnalyzerExtension(reasonableInlineRules));
+            return Collections.singletonList(new InlineAnalyzerExtension(reasonableInlineRules, languageVersionSettings));
         }
         return Collections.emptyList();
     }
@@ -74,7 +81,7 @@ public class AnalyzerExtensions {
     @NotNull
     private List<InlineAnalyzerExtension> getPropertyExtensions(@NotNull PropertyDescriptor propertyDescriptor) {
         if (InlineUtil.hasInlineAccessors(propertyDescriptor)) {
-            return Collections.singletonList(new InlineAnalyzerExtension(reasonableInlineRules));
+            return Collections.singletonList(new InlineAnalyzerExtension(reasonableInlineRules, languageVersionSettings));
         }
         return Collections.emptyList();
     }

compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineAnalyzerExtension.kt

@@ -16,6 +16,8 @@
 
 package org.jetbrains.kotlin.resolve.inline
 
+import org.jetbrains.kotlin.config.LanguageFeature
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.isInlineOnlyOrReifiable
 import org.jetbrains.kotlin.diagnostics.Errors
@@ -26,7 +28,10 @@ import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.descriptorUtil.hasDefaultValue
 
-class InlineAnalyzerExtension(private val reasonableInlineRules: Iterable<ReasonableInlineRule>) : AnalyzerExtensions.AnalyzerExtension {
+class InlineAnalyzerExtension(
+        private val reasonableInlineRules: Iterable<ReasonableInlineRule>,
+        private val languageVersionSettings: LanguageVersionSettings
+) : AnalyzerExtensions.AnalyzerExtension {
 
     override fun process(descriptor: CallableMemberDescriptor, functionOrProperty: KtCallableDeclaration, trace: BindingTrace) {
         checkModalityAndOverrides(descriptor, functionOrProperty, trace)
@@ -86,14 +91,28 @@ class InlineAnalyzerExtension(private val reasonableInlineRules: Iterable<Reason
         for (parameter in functionDescriptor.valueParameters) {
             if (parameter.hasDefaultValue()) {
                 val ktParameter = ktParameters[parameter.index]
-                //report unsupported default only on inlinable lambda and on parameter with inherited default (there is some problems to inline it)
-                if (checkInlinableParameter(parameter, ktParameter, functionDescriptor, null) || !parameter.declaresDefaultValue()) {
-                    trace.report(Errors.NOT_YET_SUPPORTED_IN_INLINE.on(ktParameter, ktParameter, functionDescriptor))
+                //Always report unsupported error on functional parameter with inherited default (there are some problems with inlining)
+                val inheritDefaultValues = !parameter.declaresDefaultValue()
+                if (checkInlinableParameter(parameter, ktParameter, functionDescriptor, null) || inheritDefaultValues) {
+                    if (inheritDefaultValues || !languageVersionSettings.supportsFeature(LanguageFeature.InlineDefaultFunctionalParameters)) {
+                        trace.report(Errors.NOT_YET_SUPPORTED_IN_INLINE.on(ktParameter, ktParameter, functionDescriptor))
+                    }
+                    else {
+                        checkDefaultValue(trace, parameter, ktParameter)
+                    }
                 }
             }
         }
     }
 
+    private fun checkDefaultValue(trace: BindingTrace, parameterDescriptor: ValueParameterDescriptor, ktParameter: KtParameter) {
+        ktParameter.defaultValue?.let { defaultValue ->
+            if (!InlineUtil.isInlinableParameterExpression(KtPsiUtil.deparenthesize(defaultValue))) {
+                trace.report(Errors.INVALID_DEFAULT_FUNCTIONAL_PARAMETER_FOR_INLINE.on(defaultValue, defaultValue, parameterDescriptor))
+            }
+        }
+    }
+
     private fun checkModalityAndOverrides(
             callableDescriptor: CallableMemberDescriptor,
             functionOrProperty: KtCallableDeclaration,

compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineUtil.java

@@ -200,4 +200,10 @@ public class InlineUtil {
 
         return false;
     }
+
+    public static boolean isInlinableParameterExpression(@Nullable KtExpression deparenthesized) {
+        return deparenthesized instanceof KtLambdaExpression ||
+               deparenthesized instanceof KtNamedFunction ||
+               deparenthesized instanceof KtCallableReferenceExpression;
+    }
 }

compiler/testData/codegen/boxInline/defaultValues/varArgNoInline.kt

@@ -0,0 +1,20 @@
+// FILE: 1.kt
+//WITH_RUNTIME
+package test
+
+var res = ""
+
+inline fun inlineFun(vararg s : () -> String = arrayOf({ "OK" })) {
+    for (p in s) {
+        res += p()
+    }
+}
+
+// FILE: 2.kt
+//NO_CHECK_LAMBDA_INLINING
+import test.*
+
+fun box(): String {
+    inlineFun()
+    return res
+}

compiler/testData/diagnostics/tests/inline/defaultLambdaInlineDisable.kt

@@ -0,0 +1,48 @@
+// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE
+// !LANGUAGE: -InlineDefaultFunctionalParameters
+
+fun test() = "OK"
+
+val prop = "OK"
+
+class Foo {
+    fun test() = "OK"
+    val prop = "OK"
+}
+
+object FooObject {
+    fun test() = "OK"
+    val prop = "OK"
+}
+
+inline fun default1(<!NOT_YET_SUPPORTED_IN_INLINE!>s : () -> String = { "OK" }<!>) {}
+inline fun default2(<!NOT_YET_SUPPORTED_IN_INLINE!>s : () -> String = ::test<!>) {}
+inline fun default3(<!NOT_YET_SUPPORTED_IN_INLINE!>s : () -> String = ::prop<!>) {}
+inline fun default4(<!NOT_YET_SUPPORTED_IN_INLINE!>s : () -> String = FooObject::test<!>) {}
+inline fun default5(<!NOT_YET_SUPPORTED_IN_INLINE!>s : () -> String = FooObject::prop<!>) {}
+inline fun default6(<!NOT_YET_SUPPORTED_IN_INLINE!>s : (a: Foo) -> String = Foo::test<!>) {}
+inline fun default7(<!NOT_YET_SUPPORTED_IN_INLINE!>s : (a: Foo) -> String = Foo::prop<!>) {}
+
+val a = Foo()
+
+inline fun default8(<!NOT_YET_SUPPORTED_IN_INLINE!>s : () -> String = a::test<!>) {}
+inline fun default9(<!NOT_YET_SUPPORTED_IN_INLINE!>s : () -> String = a::prop<!>) {}
+
+inline fun default10(<!NOT_YET_SUPPORTED_IN_INLINE!>s : () -> String = object : Function0<String> {
+    override fun invoke(): String {
+        return "FAIL"
+    }
+}<!>) {}
+
+
+abstract class Base {
+    abstract fun foo(f: () -> Unit = { })
+}
+
+class Derived : Base() {
+    <!OVERRIDE_BY_INLINE!>override final inline fun foo(<!NOT_YET_SUPPORTED_IN_INLINE!>f: () -> Unit<!>)<!> {
+        f()
+    }
+}
+
+inline fun default11(<!NOT_YET_SUPPORTED_IN_INLINE!>s : () -> Derived = ::Derived<!>) {}

compiler/testData/diagnostics/tests/inline/defaultLambdaInlineDisable.txt

@@ -0,0 +1,50 @@
+package
+
+public val a: Foo
+public val prop: kotlin.String = "OK"
+public inline fun default1(/*0*/ s: () -> kotlin.String = ...): kotlin.Unit
+public inline fun default10(/*0*/ s: () -> kotlin.String = ...): kotlin.Unit
+public inline fun default11(/*0*/ s: () -> Derived = ...): kotlin.Unit
+public inline fun default2(/*0*/ s: () -> kotlin.String = ...): kotlin.Unit
+public inline fun default3(/*0*/ s: () -> kotlin.String = ...): kotlin.Unit
+public inline fun default4(/*0*/ s: () -> kotlin.String = ...): kotlin.Unit
+public inline fun default5(/*0*/ s: () -> kotlin.String = ...): kotlin.Unit
+public inline fun default6(/*0*/ s: (a: Foo) -> kotlin.String = ...): kotlin.Unit
+public inline fun default7(/*0*/ s: (a: Foo) -> kotlin.String = ...): kotlin.Unit
+public inline fun default8(/*0*/ s: () -> kotlin.String = ...): kotlin.Unit
+public inline fun default9(/*0*/ s: () -> kotlin.String = ...): kotlin.Unit
+public fun test(): kotlin.String
+
+public abstract class Base {
+    public constructor Base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ f: () -> kotlin.Unit = ...): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class Derived : Base {
+    public constructor Derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final inline override /*1*/ fun foo(/*0*/ f: () -> kotlin.Unit = ...): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class Foo {
+    public constructor Foo()
+    public final val prop: kotlin.String = "OK"
+    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 fun test(): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public object FooObject {
+    private constructor FooObject()
+    public final val prop: kotlin.String = "OK"
+    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 fun test(): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/inline/defaultLambdaInlining.kt

@@ -0,0 +1,47 @@
+// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE
+// !LANGUAGE: +InlineDefaultFunctionalParameters
+
+fun test() = "OK"
+
+val prop = "OK"
+
+class Foo {
+    fun test() = "OK"
+    val prop = "OK"
+}
+
+object FooObject {
+    fun test() = "OK"
+    val prop = "OK"
+}
+
+inline fun default1(s : () -> String = {"OK"}) {}
+inline fun default2(s : () -> String = ::test) {}
+inline fun default3(s : () -> String = ::prop) {}
+inline fun default4(s : () -> String = FooObject::test) {}
+inline fun default5(s : () -> String = FooObject::prop) {}
+inline fun default6(s : (a: Foo) -> String = Foo::test) {}
+inline fun default7(s : (a: Foo) -> String = Foo::prop) {}
+
+val a = Foo()
+
+inline fun default8(s : () -> String = a::test) {}
+inline fun default9(s : () -> String = a::prop) {}
+
+inline fun default10(s : () -> String = <!INVALID_DEFAULT_FUNCTIONAL_PARAMETER_FOR_INLINE!>object : Function0<String><!> {
+    override fun invoke(): String {
+        return "FAIL"
+    }
+}) {}
+
+abstract class Base {
+    abstract fun foo(f: () -> Unit = { })
+}
+
+class Derived : Base() {
+    <!OVERRIDE_BY_INLINE!>override final inline fun foo(<!NOT_YET_SUPPORTED_IN_INLINE!>f: () -> Unit<!>)<!> {
+        f()
+    }
+}
+
+inline fun default11(s : () -> Derived = ::Derived) {}

compiler/testData/diagnostics/tests/inline/defaultLambdaInlining.txt

@@ -0,0 +1,50 @@
+package
+
+public val a: Foo
+public val prop: kotlin.String = "OK"
+public inline fun default1(/*0*/ s: () -> kotlin.String = ...): kotlin.Unit
+public inline fun default10(/*0*/ s: () -> kotlin.String = ...): kotlin.Unit
+public inline fun default11(/*0*/ s: () -> Derived = ...): kotlin.Unit
+public inline fun default2(/*0*/ s: () -> kotlin.String = ...): kotlin.Unit
+public inline fun default3(/*0*/ s: () -> kotlin.String = ...): kotlin.Unit
+public inline fun default4(/*0*/ s: () -> kotlin.String = ...): kotlin.Unit
+public inline fun default5(/*0*/ s: () -> kotlin.String = ...): kotlin.Unit
+public inline fun default6(/*0*/ s: (a: Foo) -> kotlin.String = ...): kotlin.Unit
+public inline fun default7(/*0*/ s: (a: Foo) -> kotlin.String = ...): kotlin.Unit
+public inline fun default8(/*0*/ s: () -> kotlin.String = ...): kotlin.Unit
+public inline fun default9(/*0*/ s: () -> kotlin.String = ...): kotlin.Unit
+public fun test(): kotlin.String
+
+public abstract class Base {
+    public constructor Base()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun foo(/*0*/ f: () -> kotlin.Unit = ...): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class Derived : Base {
+    public constructor Derived()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public final inline override /*1*/ fun foo(/*0*/ f: () -> kotlin.Unit = ...): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class Foo {
+    public constructor Foo()
+    public final val prop: kotlin.String = "OK"
+    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 fun test(): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public object FooObject {
+    private constructor FooObject()
+    public final val prop: kotlin.String = "OK"
+    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 fun test(): kotlin.String
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java

@@ -11053,6 +11053,18 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest {
                 doTest(fileName);
             }
 
+            @TestMetadata("defaultLambdaInlineDisable.kt")
+            public void testDefaultLambdaInlineDisable() throws Exception {
+                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/defaultLambdaInlineDisable.kt");
+                doTest(fileName);
+            }
+
+            @TestMetadata("defaultLambdaInlining.kt")
+            public void testDefaultLambdaInlining() throws Exception {
+                String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/defaultLambdaInlining.kt");
+                doTest(fileName);
+            }
+
             @TestMetadata("extensionOnFunction.kt")
             public void testExtensionOnFunction() throws Exception {
                 String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/inline/extensionOnFunction.kt");

compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxInlineCodegenTestGenerated.java

@@ -941,6 +941,12 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo
             doTest(fileName);
         }
 
+        @TestMetadata("varArgNoInline.kt")
+        public void testVarArgNoInline() throws Exception {
+            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/boxInline/defaultValues/varArgNoInline.kt");
+            doTest(fileName);
+        }
+
         @TestMetadata("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)

compiler/tests/org/jetbrains/kotlin/codegen/CompileKotlinAgainstInlineKotlinTestGenerated.java

@@ -941,6 +941,12 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi
             doTest(fileName);
         }
 
+        @TestMetadata("varArgNoInline.kt")
+        public void testVarArgNoInline() throws Exception {
+            String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/codegen/boxInline/defaultValues/varArgNoInline.kt");
+            doTest(fileName);
+        }
+
         @TestMetadata("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)

compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt

@@ -50,6 +50,7 @@ enum class LanguageFeature(
     DefaultImportOfPackageKotlinComparisons(KOTLIN_1_1),
 
     ArrayLiteralsInAnnotations(KOTLIN_1_2),
+    InlineDefaultFunctionalParameters(KOTLIN_1_2),
 
     // Experimental features