Thing thing

                @OutputFile
                RegularFile outputFile

                @TaskAction def go() {
                    outputFile.asFile.text = thing.name
                }
            }

            task a(type: ThingTask) {
                thing = objects.named(Thing, providers.systemProperty('name').getOrElse('a'))
                outputFile = layout.projectDirectory.file("out.txt")

                abstract Property<$type> getInput()

                @OutputFile
                abstract RegularFileProperty getOutputFile()

                @TaskAction
                def action() {
                    println(input.get())
                }
            }

            tasks.register("verify", TaskWithInput) {
                outputFile.set(layout.buildDirectory.file('output.txt'))

 */

package org.gradle.api.reporting;

import org.gradle.api.file.RegularFileProperty;
import org.gradle.api.tasks.OutputFile;

/**
 * A report that is a single file.
 */
public interface SingleFileReport extends ConfigurableReport {
    @Override
    @OutputFile
    RegularFileProperty getOutputLocation();

    /**
     * Always returns {@link Report.OutputType#FILE}
     *

                _ * getAsFile() >> tmpDir.file(path)
            }
        }
    }

    abstract TestFile getOutputFile()

    void assertOutputFile(String contents) {
        assert outputFile.file
        assert outputFile.text == toPlatformLineSeparators(contents)
    }

    @get:OutputFile
    abstract val outputFile: RegularFileProperty

    @get:CompileClasspath
    abstract val classpath: ConfigurableFileCollection

    @get:Input
    abstract val excludes: ListProperty<String>

    init {
        excludes.convention(DEFAULT_EXCLUDES)
    }

    @TaskAction
    fun generate() {

    }

    @Override
    protected List<String> getOutputArgs(CppPCHCompileSpec spec, File outputFile) {
        return Collections.singletonList("/Fp" + outputFile.getAbsolutePath());
    }

}

func Parse() {
	objabi.Flagparse(Usage)
	if flag.NArg() == 0 {
		flag.Usage()
	}

	// Flag refinement.
	if *OutputFile == "" {
		if flag.NArg() != 1 {
			flag.Usage()
		}
		input := filepath.Base(flag.Arg(0))
		input = strings.TrimSuffix(input, ".s")
		*OutputFile = fmt.Sprintf("%s.o", input)
	}

                @Nested
                abstract Property<JavaLauncher> getLauncher1()
                @OutputFile
                abstract RegularFileProperty getOutputFile()

                @TaskAction
                void myAction() {
                    def output = outputFile.get().asFile
                    output << launcher1.get().executablePath
                }
            }

    @Override
    public T defaultInstance() {
        T obj = create();
        obj.loadDefaults();
        return obj;
    }

    @Override
    public void write(T object, File outputFile) {
        object.store(outputFile);
    }

    }

    MutableUnitOfWorkBuilder withOutputFiles(File... outputFiles) {
        return withOutputFiles((outputFiles as List)
            .withIndex()
            .collectEntries { outputFile, index -> [('defaultFiles' + index): outputFile] }
        )
    }

    MutableUnitOfWorkBuilder withOutputFiles(Map<String, ? extends File> files) {
        this.outputFiles = files
        return this
    }