Checking for generics in RedundantLambdaParameterType

[varunmendiratta]

Expected Behavior of the rule

I am creating a custom rule RedundantLambdaParameterType where specifying type of parameters in a lambda expression is unnecessary.
Non-compliant code:

val flat = listOf(listOf(1), listOf(2)).mapIndexed { index: Int, item: List<Int> ->
                        println(item)
                        item + index 
                }

Here the types Int and List<Int> can be omitted.

However, I want to skip this rule in case of generics. For example,
fun <T, U> toPair() = BiFunction { t: T, u: U -> Pair(t, u) }
Here T, U are generics, so no violation should be reported.

What's the best way to check if type of lambda parameters refer to generics?

Here is what I have currently:

@RequiresTypeResolution
class RedundantLambdaParameterType(config: Config = Config.empty) : Rule(config) {
    override val issue = Issue(
        javaClass.simpleName,
        Severity.Style,
        "Specifying type of parameters in a lambda expression is unnecessary",
        Debt.FIVE_MINS
    )

    override fun visitLambdaExpression(lambdaExpression: KtLambdaExpression) {
        super.visitLambdaExpression(lambdaExpression)
        if (bindingContext == BindingContext.EMPTY) return

        val typeReferences = lambdaExpression.valueParameters.map { it.typeReference }
        // Checks if types are specified for any lambda parameter
        if (typeReferences.any { it != null }) {
            typeReferences.forEach { typeReference ->
                if (typeReference.isGeneric()) { //what should be definition of isGeneric()
                    return
                }
            }
            
            report(
                CodeSmell(
                    issue,
                    Entity.from(lambdaExpression),
                    "The parameters in a lambda expressions should not specify a type. " +
                        "You can safely remove them."
                )
            )
        }
    }
}

Context

A rule which reports when a lambda expression is specifying type of parameters.

[schalkms]

The ArrayPrimitive rule in this repo is a good example on how to check generic type arguments. You can have a look here.