op.getLoc(), op.getType(), batchInputOp.getInputDataset(),
        batchInputOp.getOtherArguments(), op.getBatchSize(),
        num_parallel_calls_op.getY(), op.getDropRemainder(),
        batchInputOp.getF(), op.getOutputTypes(), op.getOutputShapes(),
        batchInputOp.getPreserveCardinality(), op.getMetadata());
    rewriter.replaceOp(op, {fused_op.getHandle()});
    return failure();
  }
};

    templateData.name = 'test'
    templateData.variables = [year: '2012']
    outputDir = file(layout.buildDirectory.dir('genOutput'))
}

interface Injected {
    @Inject FileSystemOperations getFs()
}

// tag::ad-hoc-task[]
tasks.register('processTemplatesAdHoc') {
    inputs.property('engine', TemplateEngineType.FREEMARKER)
    inputs.files(fileTree('src/templates'))
        .withPropertyName('sourceFiles')

    @Inject
    abstract WorkerLeaseService getWorkerLeaseService();

    @Inject
    abstract ObjectFactory getObjects()

    @Inject
    abstract FileSystemOperations getFs()

    @Inject
    abstract ArchiveOperations getArchives()

    @Inject
    abstract ExecOperations getExecOps()

    @TaskAction
    def transform() {
        logging.captureStandardOutput(LogLevel.INFO)

  if (!nested_module) return;

  InlinerInterface inliner(&getContext());
  auto walk_result = getOperation().walk([&](TF::PartitionedCallOp call_op) {
    if (!call_op.getF().getRootReference().getValue().starts_with(
            kNestedModule))
      return WalkResult::advance();
    // This is a call we need to inline!
    LLVM_DEBUG(llvm::dbgs()

	if err != nil {
		return nil, err
	}
	if filter != nil && !filter.Contains(uid) {
		return nil, nil
	}

	netns, err := proc.Open(netnsName)
	if err != nil {
		return nil, err
	}
	fd, err := GetFd(netns)
	if err != nil {
		netns.Close()
		return nil, err
	}
	netnsObserved[inode] = struct{}{}
	log.Debugf("found pod to netns: %s %d", uid, inode)

	return &PodNetnsEntry{
		uid:     uid,

    @InputFile
    abstract RegularFileProperty getToolingApiShadedJar()

    @Input
    abstract Property<String> getProjectVersion()

    @Inject
    protected abstract FileSystemOperations getFs()

    @OutputDirectory
    File projectDirectory

    @TaskAction
    void generateBuildshipProject() {

        File jarFile = toolingApiShadedJar.get().asFile

                @Input
                abstract Property<String> getContent() // set to empty string to delete directory

                @Inject
                abstract FileSystemOperations getFs()

                DirProducer() {
                    content.convention("content")
                }

                @TaskAction
                def go() {
                    def dir = output.get().asFile

      }
      Operation* symbol = symbol_table.lookup(caller.getF());
      if (symbol == nullptr) {
        func.emitError() << "Symbol not found in SymbolTable: "
                         << caller.getF();
        return LogicalResult::failure();
      }
      if (!llvm::isa<func::FuncOp>(symbol)) {
        func.emitError() << "Invalid callee: " << caller.getF();
        return LogicalResult::failure();
      }

 */
public abstract class GradleJavadocsPlugin implements Plugin<Project> {

    @Inject
    protected abstract FileSystemOperations getFs();

    @Override
    public void apply(Project project) {
        ProjectLayout layout = project.getLayout();
        TaskContainer tasks = project.getTasks();

                @OutputFile File outputFile = new File(temporaryDir, "output.txt")
                @Input String run = project.findProperty("run") ?: ""
                @javax.inject.Inject abstract FileSystemOperations getFs()
                @TaskAction
                void generate() {
                    logger.warn("Run " + run)
                    fs.copy {
                        from("output.txt")