@Internal
                abstract SetProperty<ResolvedArtifactResult> getResolvedArtifacts()

                @OutputFile
                abstract RegularFileProperty getOutputFile()

                @TaskAction
                void action() {
                    println(artifactFiles.files)
                    println(resolvedArtifacts.get())
                }
            }

}

@DisableCachingByDefault(because = "Not worth caching")
abstract class CreateBuildshipEclipseProjectTask extends DefaultTask {

    @InputFile
    abstract RegularFileProperty getToolingApiShadedJar()

    @Input
    abstract Property<String> getProjectVersion()

    @Inject
    protected abstract FileSystemOperations getFs()

    @OutputDirectory
    File projectDirectory

                kotlin("android")
            }

            abstract class CustomFieldValueProvider : DefaultTask() {

                @get:OutputFile
                abstract val fieldValueOutputFile: RegularFileProperty

                @TaskAction fun writeFieldValue() {
                    fieldValueOutputFile.get().asFile.writeText("42")
                }
            }

     * class Producer extends DefaultTask {
     *     {@literal @}OutputFile
     *     abstract RegularFileProperty getOutputFile()
     *
     *     //irrelevant details omitted
     * }
     *
     * class Consumer extends DefaultTask {
     *     {@literal @}InputFile
     *     abstract RegularFileProperty getInputFile()
     *
     *     //irrelevant details omitted
     * }
     *

public abstract class GenerateReportTask extends DefaultTask {

    @InputDirectory
    File sourceDirectory

}
----
=====
====

Similarly, for the output, we use a `RegularFileProperty` and annotate it with `@OutputFile`.

====
[.multi-language-sample]
=====
.buildSrc/src/main/kotlin/GenerateReportTask.kt
[source,kotlin]
----
import org.gradle.api.DefaultTask

        """

        expect:
        succeeds()
    }

    def "can create instance of interface with read-only RegularFileProperty property"() {
        buildFile """
            interface Thing {
                RegularFileProperty getValue()
            }

            extensions.create("thing", Thing)
            assert thing.value.toString() == "extension 'thing' property 'value'"

        buildFile << """
            abstract class MyTask extends DefaultTask {
                @Internal abstract DirectoryProperty getFoo()
                @Internal abstract RegularFileProperty getBar()

                @TaskAction
                void useIt() {
                    assert foo.asFile.get().name == "foo"
                    assert bar.asFile.get().name == "bar"
                }

                @get:Input
                abstract val taskInput: $propertyType

                @get:OutputFile
                abstract val outputFile: RegularFileProperty

                @TaskAction
                fun doWork() {
                    workerExecutor.${isolationMode.method}().submit(TestWorkAction::class) {
                        workInput = taskInput

                    }
                }
            }

            abstract class Producer extends DefaultTask {
                @OutputFile abstract RegularFileProperty getOutputFile()
                @TaskAction def produce() {
                    outputFile.get().asFile << "42"
                }
            }

                abstract DirectoryProperty getSources()

                @InputFiles
                abstract ConfigurableFileCollection getSourceFiles()

                @OutputFile
                abstract RegularFileProperty getZipFile()

                ZipSrc() {
                    // We need a way to count access times, that is why I ended up with configuring it in the task so it has access to countResolved.