class Rules extends RuleSource {
            @Model
            void fss(FunctionalSourceSet sources) {
            }

            @Mutate void printTask(ModelMap<Task> tasks, FunctionalSourceSet sources) {
                tasks.create("printTask") {
                    doLast {
                        println "name: " + sources.name
                        println "display-name: " + sources.displayName

        buildFile '''
            abstract class PrintTask extends DefaultTask {
                @OutputFile
                abstract RegularFileProperty getOutput()

                @TaskAction
                def action() {
                    output.get().asFile.text = "Hello"
                }
            }

            def printTask = tasks.register('print', PrintTask) {

        """.stripIndent()
    }

    private String addPrintSourceDirTask() {
        """
            class PrintSourceDirectoryRules extends RuleSource {
                @Mutate void printTask(ModelMap<Task> tasks, LanguageSourceSet lss) {
                    tasks.create("printSourceDirs") {
                      doLast {
                        println ("source dirs: \${lss.source.getSrcDirs()}")

            class MyPlugin {
                static class Rules extends RuleSource {
                    @Mutate void addPrintTask(ModelMap<Task> tasks, List<String> strings) {
                        tasks.create("printMessage", PrintTask) {
                            it.message = strings
                        }
                    }

                    @Model String foo() {
                        "foo"
                    }

#include "tensorflow/compiler/mlir/tensorflow/transforms/tf_passes.h.inc"

class PrintPass : public impl::PrintPassBase<PrintPass> {
 public:
  explicit PrintPass(raw_ostream* os = nullptr);
  PrintPass(const PrintPass& other);
  void runOnOperation() override;

 private:
  llvm::sys::SmartMutex<true> mutex_;
  raw_ostream* os_;
};

PrintPass::PrintPass(raw_ostream* os) {
  if (os) {
    os_ = os;
  } else {

	parserMode parser.Mode
)

func initParserMode() {
	if *allErrors {
		parserMode |= parser.AllErrors
	}
	if *printAST {
		sequential = true
	}
	if *printTrace {
		parserMode |= parser.Trace
		sequential = true
	}
	if *parseComments && (*printAST || *printTrace) {
		parserMode |= parser.ParseComments
	}
}

const usageString = `usage: gotype [flags] [path ...]

	return fmt.Sprintf("%*s%sBuiltinType: %s", indent, "", field, bt.Name)
}

func (bt *BuiltinType) prec() precedence {
	return precPrimary
}

// printBase is common print code for types that are printed with a
// simple suffix.
func printBase(ps *printState, qual, base AST) {
	ps.inner = append(ps.inner, qual)
	ps.print(base)
	if len(ps.inner) > 0 {
		qual.(innerPrinter).printInner(ps)

    that it matches that of the subsequent TPUExecute{,AndUpdateVariables}
    op.
  }];
  let constructor = "TFTPU::CreateColocateTPUCopyWithDynamicShapePass()";
}

def PrintPass : Pass<"tf-print", "ModuleOp"> {
  let summary = "Prints the current module.";
  let description = [{
    This prints the current module (by default, to stderr). The module is
    otherwise piped through without changes.