<T>: kotlin.String
                  $receiver: GET_VAR 'p0: kotlin.String declared in <root>.CodeFragment.run' type=kotlin.String origin=null
                  predicate: FUN_EXPR type=kotlin.Function1<kotlin.String, kotlin.Boolean> origin=LAMBDA

KaDataFlowExitPointSnapshot:
  defaultExpressionInfo = DefaultExpressionInfo:
    expression = fun(n: Int): Int {
            return n + 1
        }
    type = kotlin.Function1<kotlin.Int, kotlin.Int>
  hasEscapingJumps = false
  hasJumps = false
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = []
  returnValueType = null
  valuedReturnExpressions = []

     * // source code
     * fun test() {
     *   val action = foo()
     *   action("") // this call
     * }
     * ```
     *
     * Unfortunately, [symbol] for the `action("")` call will be pointing to the `Function1<P1, R>.invoke(p1: P1): R`, because we
     * intentionally unwrap use-site substitution overrides. Because of this, `symbol.name` will yield `"p1"`, and not `"bar"`.
     *

    @Test
    fun `#kotlinTypeStringFor Kotlin function type`() {
        assertThat(
            kotlinTypeStringFor(typeOf<(String) -> String>()),
            equalTo("kotlin.jvm.functions.Function1<String, String>")
        )
    }

    @Test
    fun `#kotlinTypeStringFor Java function type`() {
        assertThat(
            kotlinTypeStringFor(typeOf<java.util.function.Function<String, String>>()),

import com.tngtech.archunit.core.domain.JavaClass;
import com.tngtech.archunit.junit.AnalyzeClasses;
import com.tngtech.archunit.junit.ArchTest;
import com.tngtech.archunit.lang.ArchRule;
import kotlin.Pair;
import kotlin.jvm.functions.Function1;
import kotlin.reflect.KClass;
import kotlin.reflect.KProperty;
import org.gradle.api.NamedDomainObjectCollection;
import org.gradle.api.Plugin;
import org.gradle.api.Task;
import org.gradle.api.specs.Spec;

    /**
     * Maps a simple name `N` to type aliases `A` in whose definition `N` occurs as the topmost user type, which is a prerequisite for other
     * classes inheriting from `N` by referring to `A`. Does not support function types (e.g. `Function1`).
     *
     * There is no guarantee that the type alias can be inherited from. For example, if its expanded type is final, the type alias is not

            import org.gradle.api.reflect.*;
            import java.util.function.Function;

            public class MyPlugin implements Plugin<Project> {
                public void apply(Project project) {
                    TypeOf<Function<String, String>> typeToken = new TypeOf<Function<String, String>>() {};
                    Function<String, String> lambda = s -> s.toUpperCase();

        && api.type.arguments[0].type!!.isTypeArgumentCompatibleWith(type.arguments[0].type!!)


private
fun KParameter.isSamWithReceiverReturningUnit() =
    type.jvmErasure == Function1::class
        && type.arguments[1] == KTypeProjection(KVariance.INVARIANT, Unit::class.createType())


private
fun KParameter.isVarargCompatibleWith(api: KParameter) =

// (that would indicate a slice type). Thus, generic functions cannot
// have empty type parameter lists, either. This is a syntax error.

func h[] /* ERROR "empty type parameter list" */ () {}

func _() {
	h /* ERROR "cannot index" */ [] /* ERROR "operand" */ ()
}

// Generic functions must have a function body.

/**
 * Legacy version of {@link java.util.function.Function java.util.function.Function}.
 *
 * <p>The {@link Functions} class provides common functions and related utilities.
 *
 * <p>As this interface extends {@code java.util.function.Function}, an instance of this type can be
 * used as a {@code java.util.function.Function} directly. To use a {@code
 * java.util.function.Function} in a context where a {@code com.google.common.base.Function} is