if (!locations.empty()) {
      // Skip locations for propagating op_type metadata.
      if (auto name_loc = mlir::dyn_cast<mlir::NameLoc>(locations[0])) {
        if (name_loc.getName().strref().ends_with(":")) {
          if (locations.size() == 2)
            return locations[1];
          else if (locations.size() > 2)
            return mlir::FusedLoc::get(
                fused_loc.getContext(),

          // op_type metadata.
          if (num_locs > 0) {
            if (auto name_loc = mlir::dyn_cast<mlir::NameLoc>(locations[0])) {
              if (name_loc.getName().strref().ends_with(":")) {
                if (num_locs == 2) {
                  return LocationExtractor(locations[1]).Extract(error_data);
                } else if (num_locs > 2) {

  StringRef caller_name =
      mlir::cast<NameLoc>(callsite_loc.getCaller()).getName().strref();
  return caller_name.starts_with(kQuantizationUnitPrefix) &&
         caller_name.ends_with(kQuantizationUnitSuffix);
}

std::optional<QuantizationUnitLoc::QuantizationUnit>
FindQuantizationUnitFromLoc(Location loc) {
  if (isa<QuantizationUnitLoc>(loc)) {

// Returns the associated option name for the given op definition.
static inline std::string GetOperatorOptionName(const Record &def) {
  assert(def.getName().starts_with("TFL_") && "unexpected op prefix");
  assert(def.getName().ends_with("Op") && "unexpected op suffix");

  auto *custom_option = dyn_cast<StringInit>(def.getValueInit("customOption"));
  std::ostringstream oss;
  if (custom_option)
    oss << custom_option->getValue().str();
  else

  if (locations.size() < 2 || !isa<NameLoc>(locations.front())) return false;

  StringRef op_type_with_suffix =
      mlir::cast<NameLoc>(locations.front()).getName().strref();
  if (!op_type_with_suffix.ends_with(":")) return false;

  return absl::c_all_of(locations, [](Location loc) {
    return isa<NameLoc>(loc) ||
           (isa<CallSiteLoc>(loc) &&
            isa<NameLoc>(mlir::cast<CallSiteLoc>(loc).getCallee()));
  });

        when:
        def folders = regularSourceFolders()
        then:
        folders.find { it.dir.path.endsWith("java") }.excludes == []
        folders.find { it.dir.path.endsWith("java") }.includes == patterns
        folders.find { it.dir.path.endsWith("resources") }.excludes == patterns
        folders.find { it.dir.path.endsWith("resources") }.includes == []
    }

    return when {
      file.name.endsWith(".css") -> "text/css"
      file.name.endsWith(".gif") -> "image/gif"
      file.name.endsWith(".html") -> "text/html"
      file.name.endsWith(".jpeg") -> "image/jpeg"
      file.name.endsWith(".jpg") -> "image/jpeg"
      file.name.endsWith(".js") -> "application/javascript"
      file.name.endsWith(".png") -> "image/png"
      else -> "text/plain"
    }
  }

    return result;
  }

  private String contentType(String path) {
    if (path.endsWith(".png")) return "image/png";
    if (path.endsWith(".jpg")) return "image/jpeg";
    if (path.endsWith(".jpeg")) return "image/jpeg";
    if (path.endsWith(".gif")) return "image/gif";
    if (path.endsWith(".html")) return "text/html; charset=utf-8";
    if (path.endsWith(".txt")) return "text/plain; charset=utf-8";
    return "application/octet-stream";
  }

        final String path = imageFile.getAbsolutePath();
        if (path.endsWith(".png")) {
            return "image/png";
        }
        if (path.endsWith(".gif")) {
            return "image/gif";
        }
        if (path.endsWith(".jpg") || path.endsWith(".jpeg")) {
            return "image/jpeg";
        }
        return "application/octet-stream";
    }

                def names = it.entries()*.name
                def groupedNames = names.groupBy { it }
                groupedNames.each { name, all ->
                    if (name.endsWith(".class") && !name.endsWith("module-info.class") && !name.endsWith("package-info.class")) {
                        def containingJars = classesIndex.computeIfAbsent(name, k -> [])
                        containingJars.add(jar.name)
                    }