class CustomTask extends DefaultTask {
                @Input
                String val

                @OutputFile
                File outputFile = new File(temporaryDir, "output.txt")

                @TaskAction
                void generate() {
                    outputFile.text = val
                }
            }

            task customTask(type: CustomTask) { val = "$val" }
        """

		ctxt.Retpoline = true
	}

	ctxt.Bso = bufio.NewWriter(os.Stdout)
	defer ctxt.Bso.Flush()

	architecture.Init(ctxt)

	// Create object file, write header.
	buf, err := bio.Create(*flags.OutputFile)
	if err != nil {
		log.Fatal(err)
	}
	defer buf.Close()

	if !*flags.SymABIs {
		buf.WriteString(objabi.HeaderString())
		fmt.Fprintf(buf, "!\n")
	}

  std::string error;
  std::unique_ptr<llvm::ToolOutputFile> outputFile =
      mlir::openOutputFile(filename, &error);
  if (!error.empty()) {
    TF_SetStatus(status, TF_INVALID_ARGUMENT,
                 ("Unable to create output file " + error).c_str());
    return;
  }
  outputFile->keep();
  if (failed(mlir::writeBytecodeToFile(*module, outputFile->os(),
                                       writer_config))) {

                'Use a different annotation, e.g one of @Console, @Destroys, @Inject, @Input, @InputDirectory, @InputFile, @InputFiles, @Internal, @LocalState, @Nested, @OptionValues, @OutputDirectories, @OutputDirectory, @OutputFile, @OutputFiles, @ReplacedBy or @ServiceReference',
            ]
            additionalData.asMap == [
                'parentPropertyName' : 'options',
                'typeName' : 'MyTask',

                @Input
                String fileName = name + ".txt"

                @OutputFile
                File outputFile = new File(project.buildDir, name + "-output.txt")

                @TaskAction
                void generate() {
                    outputFile.text = message
                    localStateDir.mkdir()
                    def localStateFile = new File(localStateDir, fileName)

        buildFile << """
            task cacheableTask {
                def inputFile = file("src/dummy-input.txt")
                def outputDir = file(layout.buildDirectory.dir("dummy-output"))
                def outputFile = file(layout.buildDirectory.file("dummy-output/result.txt"))

                outputs.cacheIf { true }

                inputs.files(inputFile)
                    .withPropertyName("dummy-input")

            writeEnum(filePropertyType)
        }
    }
}


private
fun collectRegisteredOutputsOf(task: Task): List<RegisteredProperty.OutputFile> {

    val properties = mutableListOf<RegisteredProperty.OutputFile>()

    (task.outputs as TaskOutputsInternal).visitRegisteredProperties(object : PropertyVisitor {

        override fun visitOutputFileProperty(
            propertyName: String,

            if (backendErrors.isNotEmpty()) {
                return KaCompilationResult.Failure(backendErrors)
            }

            val outputFiles = state.factory.asList().map(::KaCompiledFileForOutputFile)
            return KaCompilationResult.Success(outputFiles, capturedValues = emptyList())
        } finally {
            state.destroy()
        }
    }

  private val testResources = projectRoot / "okhttp/src/test/resources/okhttp3/internal/publicsuffix"
  private val publicSuffixListDotDat = testResources / "public_suffix_list.dat"
  private val outputFile = resources / PUBLIC_SUFFIX_RESOURCE

  val request = Request("https://publicsuffix.org/list/public_suffix_list.dat".toHttpUrl())

  suspend fun import() {
    check(fileSystem.metadata(resources).isDirectory)

    @get:InputFiles
    abstract val inputSummaries: ConfigurableFileCollection

    @get:OutputFile
    abstract val outputFile: RegularFileProperty

    @TaskAction
    fun summarize() {
        outputFile.get().asFile.run {
            parentFile.mkdirs()
            writeText(summaryString())
        }
    }

    private