if (parts.size() == 1) {
            return Describables.of(parts.get(0));
        }
        return new MultipleVariantName(parts);
    }

    private static class MultipleVariantName implements DisplayName {
        private final List<String> parts;

        private MultipleVariantName(List<String> parts) {
            this.parts = parts;
        }

        @Override

  int64_t GetPassNumber(mlir::Pass* pass) {
    if (!pass_to_number_map_.contains(pass)) {
      pass_to_number_map_[pass] = mlir_pass_count_++;
    }
    return pass_to_number_map_[pass];
  }

  void Dump(mlir::Pass* pass, PrintCallbackFn print_callback, bool is_before) {
    auto& pass_to_dump_file_map = is_before ? pass_to_dump_file_before_map_
                                            : pass_to_dump_file_after_map_;

	// this may be called with an actual absolute path on Windows (with a C:\ prefix).
	// But the prober.fs.Walk below will execute filepath.Join(fs.root, filenameAbove), which
	// will result in an incorrect path, you can't join C:\path and C:\another\path.
	filename = strings.TrimPrefix(filename, `C:\`)
	addWatch := func(path string, info os.FileInfo, err error) error {
		if err == nil && info.IsDir() {

	g.Expect(err).To(Not(BeNil()))
}

const (
	yamlSeparator = "---\n"
)

// JoinString joins the given yaml parts into a single multipart document.
func JoinString(parts ...string) string {
	var st strings.Builder

	var lastIsNewLine bool
	for _, p := range parts {
		if len(p) == 0 {
			continue
		}
		if st.Len() != 0 {
			if !lastIsNewLine {
				_, _ = st.WriteString("\n")
			}

	Run:  runBuildTag,
}

func runBuildTag(pass *analysis.Pass) (interface{}, error) {
	for _, f := range pass.Files {
		checkGoFile(pass, f)
	}
	for _, name := range pass.OtherFiles {
		if err := checkOtherFile(pass, name); err != nil {
			return nil, err
		}
	}
	for _, name := range pass.IgnoredFiles {
		if strings.HasSuffix(name, ".go") {

#include "mlir/IR/PatternMatch.h"  // from @llvm-project
#include "mlir/Pass/Pass.h"  // from @llvm-project
#include "mlir/Pass/PassOptions.h"  // from @llvm-project
#include "mlir/Support/LLVM.h"  // from @llvm-project
#include "mlir/Support/LogicalResult.h"  // from @llvm-project
#include "tensorflow/compiler/mlir/tensorflow/ir/tf_device.h"

namespace mlir {

// Creates a pass that breaks up an island with multiple ops into multiple

	Run:  runBuildTag,
}

func runBuildTag(pass *analysis.Pass) (interface{}, error) {
	for _, f := range pass.Files {
		checkGoFile(pass, f)
	}
	for _, name := range pass.OtherFiles {
		if err := checkOtherFile(pass, name); err != nil {
			return nil, err
		}
	}
	for _, name := range pass.IgnoredFiles {
		if strings.HasSuffix(name, ".go") {
			f, err := parser.ParseFile(pass.Fset, name, nil, parser.ParseComments)

    List<String> getClasspath();

    /**
     * The module path, relative to the application home directory.
     *
     * @since 6.4
     */
    List<String> getModulePath();

    /**
     * The path of the script, relative to the application home directory.
     */
    String getScriptRelPath();

    /**
     * This system property to use to pass the script name to the application. May be null.
     */
    @Nullable

        Describables.of(123).displayName == "123"
        Describables.of(123).toString() == "123"
        Describables.of(123).capitalizedDisplayName == "123"
    }

    def "creates from parts"() {
        expect:
        Describables.of("one", "two").displayName == "one two"
        Describables.of("one", "two").toString() == "one two"
        Describables.of("one", "two").capitalizedDisplayName == "One two"

  // Instrumentation hooks. These hooks don't need to be thread-safe. The pass
  // manager runs each pass for the entire module, then it walks through
  // each op in the module and runs the pass on them, may be in async mode.
  void runBeforePass(Pass *pass, Operation *module) override;
  void runAfterPass(Pass *pass, Operation *module) override;
  void runAfterPassFailed(Pass *pass, Operation *module) override;

  // The handler to capture error messages.