final Set<ExternalResourceName> searched = new HashSet<>();

        List<String> versions = new ArrayList<>();
        boolean hasResult = false;
        for (ResourcePattern pattern : patterns) {
            ExternalResourceName metadataLocation = pattern.toModulePath(module).resolve("maven-metadata.xml");

        public PatternSet getPatternSet() {
            PatternSet patterns = patternSetFactory.create();
            assert patterns != null;
            patterns.setCaseSensitive(isCaseSensitive());
            patterns.include(this.getAllIncludes());
            patterns.includeSpecs(getAllIncludeSpecs());
            patterns.exclude(this.getAllExcludes());
            patterns.excludeSpecs(getAllExcludeSpecs());
            return patterns;

#define TENSORFLOW_COMPILER_MLIR_LITE_STABLEHLO_ODML_CONVERTER_FOLDERS_H_

namespace mlir::odml {

// Populates the pattern set with all folding patterns. These patterns
// are intended to have precedence over any other patterns added to the set.
void PopulateFolderPatterns(RewritePatternSet &patternSet);

}  // namespace mlir::odml

}

// Remove removes files matching any of the patterns from the archive.
// The patterns use the syntax of path.Match, with an extension of allowing
// a leading **/ or trailing /**, which match any number of path elements
// (including no path elements) before or after the main match.
func (a *Archive) Remove(patterns ...string) {
	a.Filter(func(name string) bool {
		for _, pattern := range patterns {
			match, err := amatch(pattern, name)

            ivyPatterns == ["https://host/[module]/[revision]/ivy.xml"]
            m2compatible
        }
    }

    def "combines layout patterns with additionally specified patterns"() {
        repository.name = 'name'
        repository.url = 'https://host/'
        repository.artifactPattern 'https://host/[other]/artifact'
        repository.ivyPattern 'https://host/[other]/ivy'

// Add op patterns.
//===----------------------------------------------------------------------===//

def AddToAddV2 : Pat<
  (TF_AddOp:$src TF_NumberTensor:$arg0, TF_NumberTensor:$arg1),
  (TF_AddV2Op:$dest $arg0, $arg1), [], [(CopyAttrs $src, $dest)]>;

//===----------------------------------------------------------------------===//
// AddV2 op patterns.

  return IsBounded(updated);
}

// Propagates more refined type by cloning op using the new operands. This
// allows all rewrite patterns that requires refined types to work without
// requiring a rewrite to the conversion pattern. Declarative rewrite pattern
// (DRR) doesn't even support conversion patterns with TableGen.
class TypePropagator : public ConversionPattern {
 public:
  explicit TypePropagator(MLIRContext* ctx)

    init {
      require(
        (pattern.startsWith("*.") && pattern.indexOf("*", 1) == -1) ||
          (pattern.startsWith("**.") && pattern.indexOf("*", 2) == -1) ||
          pattern.indexOf("*") == -1,
      ) {
        "Unexpected pattern: $pattern"
      }

      this.pattern =
        pattern.toCanonicalHost() ?: throw IllegalArgumentException("Invalid pattern: $pattern")

      when {

void PopulateTFLoweringBeforeHLOPatterns(MLIRContext *context,
                                         RewritePatternSet *patterns);

// Populates TensorFlow lowering patterns to lower some of the TensorFlow
// operations that can be represented using other TensorFlow operations.
// Patterns are from ops with some inputs or outputs that are quantized types
// only to ops that allow non-quantized types on all inputs and outputs.

		t.Run("", func(t *testing.T) {
			argPatterns := make([]ellipses.ArgPattern, len(testCase.args))
			for i, arg := range testCase.args {
				patterns, err := ellipses.FindEllipsesPatterns(arg)
				if err != nil {
					t.Fatalf("Unexpected failure %s", err)
				}
				argPatterns[i] = patterns
			}

			gotIndexes, err := getSetIndexes(testCase.args, testCase.totalSizes, testCase.envOverride, argPatterns)