Rewrite function signature rule

[paul-dingemans]

The Kotlin and Android code guidelines are more or less specific about how to write a function signature

From Android Coding style guide (https://developer.android.com/kotlin/style-guide#functions):

When a function signature does not fit on a single line, break each parameter declaration onto its own line. Parameters defined in this format should use a single indent (+4). The closing parenthesis ()) and return type are placed on their own line with no additional indent.

fun <T> Iterable<T>.joinToString(
    separator: CharSequence = ", ",
    prefix: CharSequence = "",
    postfix: CharSequence = ""
): String {
    // …
}

Although the Kotlin style guide is less specific about this topic (https://kotlinlang.org/docs/coding-conventions.html#functions) it boils down to the exact same format for multiline signatures.

The idea is to create a new rule that determines whether the function signature fits on a single line (with respect to the max_line_length) and if so, it rewrites the function signature to a single line. If the function signature does not fit on a single line, it will be formatted as shown in example before.

The concept of this rule is already working on my local machine. Known limitations so far:

• Function signatures which contain inline comments (both block and EOL comments) are ignored as it is merely impossible to decide how such comments needs to be handled. Also the comments can be placed at really weird positions from which I hardly can imagine why somebody would do so. Example:

            private /* some comment */ fun f1(a: Any, b: Any): String = "some-result"
            private fun /* some comment */ f2(a: Any, b: Any): String = "some-result"
            private fun f3 /* some comment */ (a: Any, b: Any): String = "some-result"
            private fun f4( /* some comment */ a: Any, b: Any): String = "some-result"
            private fun f5(a /* some comment */: Any, b: Any): String = "some-result"
            private fun f6(a: /* some comment */ Any, b: Any): String = "some-result"
            private fun f7(a: Any /* some comment */, b: Any): String = "some-result"
            private fun f8(a: Any, b: Any) /* some comment */: String = "some-result"
            private fun f9(a: Any, b: Any): /* some comment */ String = "some-result"
            private fun f10(a: Any, b: Any): String /* some comment */ = "some-result"
            private fun f11(
                a: Any, // An EOL comment at this place is a bit weird because it is place after the comma. From a parser perspective it seems to belong to parameter "b" instead of "a"
                b: Any
            ): String = "f10"

• When max_line_length is not set, the function signature will not be rewritten to a single line as that could result in really long and unreadable lines.

One thing that I am doubting about is whether this rule should be made configurable a bit. Not in all cases I would like to have my function be rewritten automatically. For example, I do see no real harm in having a function with two parameters to be written on a single line if it first. Starting from 3 parameters, I would dislike it. So I would like to add a configuration setting for this rule which defines that a function signature will be forced to a multiline signature if the function has too many parameters for a single line function signature. By default this configuration setting will be empty and allow an unrestricted number of parameters.

Before this rule can be launched, I need some other rules which are fixing a few unhandled spacing issues in the function signature. I will raise a separate PR for each indivual rule.