when (this) {
        is Accessor.ForExtension -> importsRequiredBy(spec.receiver, spec.type)
        is Accessor.ForConvention -> importsRequiredBy(spec.receiver, spec.type)
        is Accessor.ForTask -> importsRequiredBy(spec.type)
        is Accessor.ForContainerElement -> importsRequiredBy(spec.receiver, spec.type)
        else -> emptyList()
    }
}


private

                node = new LocalTaskNode((TaskInternal) task, new DefaultWorkValidationContext(typeOriginInspectorFactory.forTask(task)), resolveMutationsNodeFactory);
            } else {
                node = TaskInAnotherBuild.of((TaskInternal) task, workGraphController);
            }
            nodes.put(task, node);
        }

        launchTestWithTestFilter { tl ->
            tl.forTasks(':help')
        }

        then:
        !taskExecuted(':help')
    }

    def "can execute task"() {
        when:
        launchTestWithTestFilter { tl ->
            tl.forTasks(':help')
        }

        then:
        taskExecuted(':help')
    }

    def "default task is executed when forTasks() receives empty task list"() {
        setup:

                .buildFinished(new LoadEclipseModel(), buildFinishedHandler)
                .build()
                .setStandardOutput(out)
                .forTasks()
                .run()
        }

        then:
        taskExecuted(out, ":foo")
    }

    def "can use task reference in sync task list"() {
        setup:

        withConnection { connection ->
            connection.action().projectsLoaded(new TellGradleToRunAutoBuildTasks(), projectsLoadedHandler)
                .build()
                .setStandardOutput(out)
                .forTasks()
                .run()
        }

        then:
        taskExecuted(out, ":foo")
    }

    def "can use task reference in sync task list"() {
        setup:

            assert params.tasks == ['a']
            return null
        }
    }

    def "forTasks sets empty list correctly"() {
        when:
        executer.forTasks([])

        then:
        executer.operationParamsBuilder.tasks == []

        when:
        executer.forTasks(Collections.emptySet())

        then:
        executer.operationParamsBuilder.tasks == []
    }

        withConnection {
            it.action(new SimpleAction())
                .forTasks([])
                .run()
        }

        then:
        assertHasBuildSuccessfulLogging()
        result.assertTasksExecuted(":thing")
    }

    @TargetGradleVersion(">=3.0 <3.5")
    def "BuildExecuter.forTasks() should fail when it is not supported by target"() {
        when:
        withConnection {

    }

    @Override
    public BuildLauncher forTasks(String... tasks) {
        operationParamsBuilder.setTasks(Arrays.asList(tasks));
        return this;
    }

    @Override
    public BuildLauncher forTasks(Task... tasks) {
        forTasks(Arrays.asList(tasks));
        return this;
    }

    @Override
    public BuildLauncher forTasks(Iterable<? extends Task> tasks) {
        forLaunchables(tasks);

        when:
        buildScript """
            apply from: "fooTask.gradle"
            task check {
                doLast {
                    assert getTasksByName("foo", false).toList().first().name == "foo"
                }
            }
        """

        file("fooTask.gradle") << """
            model {
                tasks { create("foo") }
            }

        where:
        description                 | action
        "no task names specified"   | { ModelBuilder b -> }
        "empty array of task names" | { ModelBuilder b -> b.forTasks() }
        "empty list of task names"  | { ModelBuilder b -> b.forTasks([]) }
    }

    def "#description means do not run any tasks even when build logic injects tasks to execute"() {
        file('build.gradle') << """