it.details.pluginClass.startsWith("Plugin")
        }

        ops.size() == 3
        ops.find { it.details.buildPath == ":" }.details.pluginClass == "PluginRoot"
        ops.find { it.details.buildPath == ":a" }.details.pluginClass == "PluginA"
        ops.find { it.details.buildPath == ":b" }.details.pluginClass == "PluginB"
    }

  // Prefix, e.g. "third_party" given root_dir "third_party/tensorflow/...."
  std::vector<string> source_path_components =
      tensorflow::str_util::Split(source_dir, "/");
  auto source_tfroot_pos = std::find(source_path_components.begin(),
                                     source_path_components.end(), tf_root_dir);
  if (source_tfroot_pos != source_path_components.end()) {
    tf_prefix_dir =

            if (classPath == null) {
                Set<Class<?>> visited = new HashSet<>();
                classPath = new LinkedHashSet<>();
                find(targetClass, visited, classPath);
                classPathCache.put(targetClass, classPath);
            }
            dest.addAll(classPath);
        } finally {
            lock.unlock();
        }
    }

	if !ok || cluster == nil {
		panic(fmt.Errorf("cannot find %s, the primary cluster for %s", c.PrimaryClusterName, c.Name()))
	}
	return cluster
}

func (c Topology) PrimaryName() string {
	return c.PrimaryClusterName
}

func (c Topology) Config() Cluster {
	cluster, ok := c.AllClusters[c.ConfigClusterName]
	if !ok || cluster == nil {

import org.jetbrains.kotlin.psi.psiUtil.findDescendantOfType
import org.jetbrains.kotlin.test.services.TestServices
import org.jetbrains.kotlin.test.services.assertions

/**
 * To find the element for the use-site position, the visibility checker test looks for an element called "useSite" in the main module if

                module('org:testB:1.0')
            }
        }

        where:
        rule << [
            "select(candidates.find { it.id.module == 'testB'})",
            "select('org:testB:1.0')",
            "select('org:testB:1.1')", // we are lenient wrt to the version number
        ]
    }

            ?: error("Can't find containing declaration for $declarationAtCaret")

        val containingClass = getContainingKtLightClass(containingDeclaration, mainFile)
        val psiContext = containingClass.findLightDeclarationContext(containingDeclaration)
            ?: error("Can't find psi context for $containingDeclaration")

        val actual = analyze(mainFile) {

        def gradleBuildB = allProjects.includedBuildIdeaProjects.keySet().find { it.rootProject.name == 'buildB' }

        gradleBuildB.buildIdentifier.rootDir == buildB

        def projectB = allProjects.includedBuildIdeaProjects.get(gradleBuildB)
        projectB.modules*.name == ['buildB', 'b1', 'b2']

        def moduleB1 = projectB.modules.find {it.name == 'b1'}

tidy-go:
	@find -name go.mod -execdir go mod tidy \;

mod-download-go:
	@-GOFLAGS="-mod=readonly" find -name go.mod -execdir go mod download \;
# go mod tidy is needed with Golang 1.16+ as go mod download affects go.sum
# https://github.com/golang/go/issues/43994
	@find -name go.mod -execdir go mod tidy \;

format-go: tidy-go

                            tpu::TPUCompileMetadataProto& metadata_proto) {
  auto main_fn = module.lookupSymbol<mlir::func::FuncOp>(kEntryFuncName);
  if (!main_fn) {
    return absl::InternalError("Could not find main function in MLIR Module.");
  }

  mlir::FunctionType func_type = main_fn.getFunctionType();
  for (auto input_type : func_type.getInputs()) {
    tensorflow::TensorShape tensor_shape;