base.WarnfAt(clo.Pos(), "closure converted to global")
		}
		return clofn.Nname
	}

	// The closure is not trivial or directly called, so it's going to stay a closure.
	ir.ClosureDebugRuntimeCheck(clo)
	clofn.SetNeedctxt(true)

	// The closure expression may be walked more than once if it appeared in composite
	// literal initialization (e.g, see issue #49029).
	//

Dmitriy Vyukov <******@****.***> 1341165590 +0400

Laura Kassovic <******@****.***> 1701107622 -0800

    private final Closure closure;
    private final int resolveStrategy;
    private final boolean configurableAware;

    public static <T> ClosureBackedAction<T> of(Closure<?> closure) {
        return new ClosureBackedAction<T>(closure);
    }

    public ClosureBackedAction(Closure closure) {
        this(closure, Closure.DELEGATE_FIRST, true);
    }

Method <org.gradle.api.Project.allprojects(groovy.lang.Closure)> has arguments/return type groovy.lang.Closure that is not Gradle public API or primitive or built-in JDK classes or Kotlin classes in (Project.java:0)

    }

    def "fails to construct with multiple arg closure with incorrect subject"() {
        given:
        def closure = { Integer val, String other ->
        }

        when:
        action(closure)

        then:
        def e = thrown RuleActionValidationException
        e.message == "First parameter of rule action closure must be of type 'String'."

        this.closure = closure;
        this.inputTypes = parseInputTypes(closure);
    }

    @Override
    public List<Class<?>> getInputTypes() {
        return inputTypes;
    }

    @Override
    public void execute(T subject, List<?> inputs) {
        Closure<?> copy = (Closure<?>) closure.clone();
        copy.setResolveStrategy(Closure.DELEGATE_FIRST);
        copy.setDelegate(subject);

import groovy.lang.Closure

fun somePlugin(action: SomePluginExtension.() -> Unit) =
    SomePluginExtension.action()

object SomePluginExtension {

    fun takingParameterLessClosure(closure: Closure<*>) =
        require(closure.call() == "result") { "parameter-less closure" }

    fun takingUnaryClosure(closure: Closure<*>) =
        require(closure.call("foo") == "result from single parameter foo") { "unary closure" }

    def "throwing Exception will count as an try"() {
        given:
        def closure = Mock(Closure)
        def retryCount = 1

        when:
        RetryUtil.retry(retryCount, closure)

        then:
        thrown(Exception)
        retryCount * closure.call() >> {
            throw new Exception()
        }
    }

    def "closure succeed on second try returns retry count of 2"() {
        given:

        def e = thrown InvalidActionClosureException
        e.closure.is(closure)
        e.message == "The closure '${closure.toString()}' is not valid as an action for argument '1'. It should accept no parameters, or one compatible with type 'java.lang.String'. It accepts (java.util.Map)."
    }

    def "closure with more than one param type is given"() {
        given:
        def closure = { Map m, List l -> }
        def arg = "1"