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);
        }

    is Accessor.ForConfiguration -> fragmentsForConfiguration(accessor)
    is Accessor.ForExtension -> fragmentsForExtension(accessor)
    is Accessor.ForConvention -> fragmentsForConvention(accessor)
    is Accessor.ForTask -> fragmentsForTask(accessor)
    is Accessor.ForContainerElement -> fragmentsForContainerElement(accessor)
}


private
fun fragmentsForConfiguration(accessor: Accessor.ForConfiguration): Fragments = accessor.run {

            error(annotationInvalidInContextConfig { annotation(ann.simpleName).type('MyTask').property('options.nestedThing').forTask() }, 'validation_problems', 'annotation_invalid_in_context'),
            error(annotationInvalidInContextConfig { annotation(ann.simpleName).type('MyTask').property('thing').forTask() }, 'validation_problems', 'annotation_invalid_in_context')
        ])

        and:
        verifyAll(receivedProblem(0)) {

"""

        when:
        render annotationInvalidInContext {
            type('SomeType').property('prop')
            annotation('Invalid')
            forTask()
        }

        then:
        outputEquals """
Type 'SomeType' property 'prop' is annotated with invalid property type @Invalid.

Reason: The '@Invalid' annotation cannot be used in this context.

            validAnnotations = "@Console, @Inject, @Input, @InputDirectory, @InputFile, @InputFiles, @Internal, @Nested, @ReplacedBy or @ServiceReference"
            this
        }

        AnnotationContext forTask() {

        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 == []
    }