[llvm][StringExtras] Merge StringExtras from MLIR into LLVM

[rriddle]

Summary

This revision adds two utilities currently present in MLIR to LLVM StringExtras:

• convertToSnakeFromCamelCase

Convert a string from a camel case naming scheme, to a snake case scheme

• convertToCamelFromSnakeCase

Convert a string from a snake case naming scheme, to a camel case scheme

[lattner]

awesome!

[thakis]

Looks like this doesn't build with msvc's headers: http://45.33.8.238/win/12929/step_4.txt Probably just needs a cctype include (or use the non-namespaced c version).

[rriddle]

In D78167#1982654, @thakis wrote:

Looks like this doesn't build with msvc's headers: http://45.33.8.238/win/12929/step_4.txt Probably just needs a cctype include (or use the non-namespaced c version).

Yep, sorry about that. Added in b30246087a3c56c3dad60cadc7fb2692ed758566.

llvm/include/llvm/ADT/StringExtras.h

 
 /// Print each character of the specified string, escaping HTML special
 /// characters.
 void printHTMLEscaped(StringRef String, raw_ostream &Out);
 
 /// printLowerCase - Print each character as lowercase if it is uppercase.
 void printLowerCase(StringRef String, raw_ostream &Out);
 
+/// Converts a string from camel-case to snake-case by replacing all uppercase
+/// letters with '_' followed by the letter in lowercase, except if the
+/// uppercase letter is the first character of the string.
+std::string convertToSnakeFromCamelCase(StringRef input);
+
+/// Converts a string from snake-case to camel-case by replacing all occurrences
+/// of '_' followed by a lowercase letter with the letter in uppercase.
+/// Optionally allow capitalization of the first letter (if it is a lowercase
+/// letter)
+std::string convertToCamelFromSnakeCase(StringRef input,
+                                        bool capitalizeFirst = false);
+
 namespace detail {
 
 template <typename IteratorT>
 inline std::string join_impl(IteratorT Begin, IteratorT End,
                              StringRef Separator, std::input_iterator_tag) {
   std::string S;
   if (Begin == End)
     return S;

llvm/lib/Support/StringExtras.cpp

else
       Out << C;
   }
 }
 
 void llvm::printLowerCase(StringRef String, raw_ostream &Out) {
   for (const char C : String)
     Out << toLower(C);
 }
+
+std::string llvm::convertToSnakeFromCamelCase(StringRef input) {
+  if (input.empty())
+    return "";
+
+  std::string snakeCase;
+  snakeCase.reserve(input.size());
+  for (char c : input) {
+    if (!std::isupper(c)) {
+      snakeCase.push_back(c);
+      continue;
+    }
+
+    if (!snakeCase.empty() && snakeCase.back() != '_')
+      snakeCase.push_back('_');
+    snakeCase.push_back(llvm::toLower(c));
+  }
+  return snakeCase;
+}
+
+std::string llvm::convertToCamelFromSnakeCase(StringRef input,
+                                              bool capitalizeFirst) {
+  if (input.empty())
+    return "";
+
+  std::string output;
+  output.reserve(input.size());
+
+  // Push the first character, capatilizing if necessary.
+  if (capitalizeFirst && std::islower(input.front()))
+    output.push_back(llvm::toUpper(input.front()));
+  else
+    output.push_back(input.front());
+
+  // Walk the input converting any `*_[a-z]` snake case into `*[A-Z]` camelCase.
+  for (size_t pos = 1, e = input.size(); pos < e; ++pos) {
+    if (input[pos] == '_' && pos != (e - 1) && std::islower(input[pos + 1]))
+      output.push_back(llvm::toUpper(input[++pos]));
+    else
+      output.push_back(input[pos]);
+  }
+  return output;
+}

llvm/unittests/ADT/StringExtrasTest.cpp

 }
 
 TEST(StringExtrasTest, printHTMLEscaped) {
   std::string str;
   raw_string_ostream OS(str);
   printHTMLEscaped("ABCdef123&<>\"'", OS);
   EXPECT_EQ("ABCdef123&amp;&lt;&gt;&quot;&apos;", OS.str());
 }
+
+TEST(StringExtras, ConvertToSnakeFromCamelCase) {
+  auto testConvertToSnakeCase = [](llvm::StringRef input,
+                                   llvm::StringRef expected) {
+    EXPECT_EQ(convertToSnakeFromCamelCase(input), expected.str());
+  };
+
+  testConvertToSnakeCase("OpName", "op_name");
+  testConvertToSnakeCase("opName", "op_name");
+  testConvertToSnakeCase("_OpName", "_op_name");
+  testConvertToSnakeCase("Op_Name", "op_name");
+  testConvertToSnakeCase("", "");
+  testConvertToSnakeCase("A", "a");
+  testConvertToSnakeCase("_", "_");
+  testConvertToSnakeCase("a", "a");
+  testConvertToSnakeCase("op_name", "op_name");
+  testConvertToSnakeCase("_op_name", "_op_name");
+  testConvertToSnakeCase("__op_name", "__op_name");
+  testConvertToSnakeCase("op__name", "op__name");
+}
+
+TEST(StringExtras, ConvertToCamelFromSnakeCase) {
+  auto testConvertToCamelCase = [](bool capitalizeFirst, llvm::StringRef input,
+                                   llvm::StringRef expected) {
+    EXPECT_EQ(convertToCamelFromSnakeCase(input, capitalizeFirst),
+              expected.str());
+  };
+
+  testConvertToCamelCase(false, "op_name", "opName");
+  testConvertToCamelCase(false, "_op_name", "_opName");
+  testConvertToCamelCase(false, "__op_name", "_OpName");
+  testConvertToCamelCase(false, "op__name", "op_Name");
+  testConvertToCamelCase(false, "", "");
+  testConvertToCamelCase(false, "A", "A");
+  testConvertToCamelCase(false, "_", "_");
+  testConvertToCamelCase(false, "a", "a");
+  testConvertToCamelCase(false, "OpName", "OpName");
+  testConvertToCamelCase(false, "opName", "opName");
+  testConvertToCamelCase(false, "_OpName", "_OpName");
+  testConvertToCamelCase(false, "Op_Name", "Op_Name");
+  testConvertToCamelCase(true, "op_name", "OpName");
+  testConvertToCamelCase(true, "_op_name", "_opName");
+  testConvertToCamelCase(true, "__op_name", "_OpName");
+  testConvertToCamelCase(true, "op__name", "Op_Name");
+  testConvertToCamelCase(true, "", "");
+  testConvertToCamelCase(true, "A", "A");
+  testConvertToCamelCase(true, "_", "_");
+  testConvertToCamelCase(true, "a", "A");
+  testConvertToCamelCase(true, "OpName", "OpName");
+  testConvertToCamelCase(true, "_OpName", "_OpName");
+  testConvertToCamelCase(true, "Op_Name", "Op_Name");
+  testConvertToCamelCase(true, "opName", "OpName");
+}

mlir/include/mlir/Support/StringExtras.h

-//===- StringExtras.h - String utilities used by MLIR -----------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file contains string utility functions used within MLIR.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef MLIR_SUPPORT_STRINGEXTRAS_H
-#define MLIR_SUPPORT_STRINGEXTRAS_H
-
-#include "llvm/ADT/StringExtras.h"
-
-#include <cctype>
-
-namespace mlir {
-/// Converts a string to snake-case from camel-case by replacing all uppercase
-/// letters with '_' followed by the letter in lowercase, except if the
-/// uppercase letter is the first character of the string.
-inline std::string convertToSnakeCase(llvm::StringRef input) {
-  std::string snakeCase;
-  snakeCase.reserve(input.size());
-  for (auto c : input) {
-    if (std::isupper(c)) {
-      if (!snakeCase.empty() && snakeCase.back() != '_') {
-        snakeCase.push_back('_');
-      }
-      snakeCase.push_back(llvm::toLower(c));
-    } else {
-      snakeCase.push_back(c);
-    }
-  }
-  return snakeCase;
-}
-
-/// Converts a string from camel-case to snake_case by replacing all occurrences
-/// of '_' followed by a lowercase letter with the letter in
-/// uppercase. Optionally allow capitalization of the first letter (if it is a
-/// lowercase letter)
-inline std::string convertToCamelCase(llvm::StringRef input,
-                                      bool capitalizeFirst = false) {
-  if (input.empty()) {
-    return "";
-  }
-  std::string output;
-  output.reserve(input.size());
-  size_t pos = 0;
-  if (capitalizeFirst && std::islower(input[pos])) {
-    output.push_back(llvm::toUpper(input[pos]));
-    pos++;
-  }
-  while (pos < input.size()) {
-    auto cur = input[pos];
-    if (cur == '_') {
-      if (pos && (pos + 1 < input.size())) {
-        if (std::islower(input[pos + 1])) {
-          output.push_back(llvm::toUpper(input[pos + 1]));
-          pos += 2;
-          continue;
-        }
-      }
-    }
-    output.push_back(cur);
-    pos++;
-  }
-  return output;
-}
-} // namespace mlir
-
-#endif // MLIR_SUPPORT_STRINGEXTRAS_H

mlir/lib/Dialect/SPIRV/SPIRVDialect.cpp

 #include "mlir/Dialect/SPIRV/SPIRVOps.h"
 #include "mlir/Dialect/SPIRV/SPIRVTypes.h"
 #include "mlir/Dialect/SPIRV/TargetAndABI.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Parser.h"
-#include "mlir/Support/StringExtras.h"
 #include "mlir/Transforms/InliningUtils.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/raw_ostream.h"
 
#include "mlir/Dialect/SPIRV/SPIRVOps.cpp.inc"
 
   addInterfaces<SPIRVInlinerInterface>();
 
   // Allow unknown operations because SPIR-V is extensible.
   allowUnknownOperations();
 }
 
 std::string SPIRVDialect::getAttributeName(Decoration decoration) {
-  return convertToSnakeCase(stringifyDecoration(decoration));
+  return llvm::convertToSnakeFromCamelCase(stringifyDecoration(decoration));
 }
 
 //===----------------------------------------------------------------------===//
 // Type Parsing
 //===----------------------------------------------------------------------===//
 
 // Forward declarations.
 template <typename ValTy>

mlir/lib/Dialect/SPIRV/SPIRVOps.cpp

 #include "mlir/Dialect/SPIRV/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/SPIRVTypes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Function.h"
 #include "mlir/IR/FunctionImplementation.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/Interfaces/CallInterfaces.h"
-#include "mlir/Support/StringExtras.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/bit.h"
 
 using namespace mlir;
 
 // TODO(antiagainst): generate these strings using ODS.
 static constexpr const char kAlignmentAttrName[] = "alignment";
 static constexpr const char kBranchWeightAttrName[] = "branch_weights";
 static constexpr const char kCallee[] = "callee";
if (val.getType() !=
       ptr.getType().cast<spirv::PointerType>().getPointeeType()) {
     return op.emitOpError("mismatch in result type and pointer type");
   }
   return success();
 }
 
 static ParseResult parseVariableDecorations(OpAsmParser &parser,
                                             OperationState &state) {
-  auto builtInName =
-      convertToSnakeCase(stringifyDecoration(spirv::Decoration::BuiltIn));
+  auto builtInName = llvm::convertToSnakeFromCamelCase(
+      stringifyDecoration(spirv::Decoration::BuiltIn));
   if (succeeded(parser.parseOptionalKeyword("bind"))) {
     Attribute set, binding;
     // Parse optional descriptor binding
-    auto descriptorSetName = convertToSnakeCase(
+    auto descriptorSetName = llvm::convertToSnakeFromCamelCase(
         stringifyDecoration(spirv::Decoration::DescriptorSet));
-    auto bindingName =
-        convertToSnakeCase(stringifyDecoration(spirv::Decoration::Binding));
+    auto bindingName = llvm::convertToSnakeFromCamelCase(
+        stringifyDecoration(spirv::Decoration::Binding));
     Type i32Type = parser.getBuilder().getIntegerType(32);
     if (parser.parseLParen() ||
         parser.parseAttribute(set, i32Type, descriptorSetName,
                               state.attributes) ||
         parser.parseComma() ||
         parser.parseAttribute(binding, i32Type, bindingName,
                               state.attributes) ||
         parser.parseRParen()) {
if (parser.parseOptionalAttrDict(state.attributes))
     return failure();
 
   return success();
 }
 
 static void printVariableDecorations(Operation *op, OpAsmPrinter &printer,
                                      SmallVectorImpl<StringRef> &elidedAttrs) {
   // Print optional descriptor binding
-  auto descriptorSetName =
-      convertToSnakeCase(stringifyDecoration(spirv::Decoration::DescriptorSet));
-  auto bindingName =
-      convertToSnakeCase(stringifyDecoration(spirv::Decoration::Binding));
+  auto descriptorSetName = llvm::convertToSnakeFromCamelCase(
+      stringifyDecoration(spirv::Decoration::DescriptorSet));
+  auto bindingName = llvm::convertToSnakeFromCamelCase(
+      stringifyDecoration(spirv::Decoration::Binding));
   auto descriptorSet = op->getAttrOfType<IntegerAttr>(descriptorSetName);
   auto binding = op->getAttrOfType<IntegerAttr>(bindingName);
   if (descriptorSet && binding) {
     elidedAttrs.push_back(descriptorSetName);
     elidedAttrs.push_back(bindingName);
     printer << " bind(" << descriptorSet.getInt() << ", " << binding.getInt()
             << ")";
   }
 
   // Print BuiltIn attribute if present
-  auto builtInName =
-      convertToSnakeCase(stringifyDecoration(spirv::Decoration::BuiltIn));
+  auto builtInName = llvm::convertToSnakeFromCamelCase(
+      stringifyDecoration(spirv::Decoration::BuiltIn));
   if (auto builtin = op->getAttrOfType<StringAttr>(builtInName)) {
     printer << " " << builtInName << "(\"" << builtin.getValue() << "\")";
     elidedAttrs.push_back(builtInName);
   }
 
   printer.printOptionalAttrDict(op->getAttrs(), elidedAttrs);
 }
 
if (!initOp || !(isa<spirv::ConstantOp>(initOp) ||    // for normal constant
                      isa<spirv::ReferenceOfOp>(initOp) || // for spec constant
                      isa<spirv::AddressOfOp>(initOp)))
       return varOp.emitOpError("initializer must be the result of a "
                                "constant or spv.globalVariable op");
   }
 
   // TODO(antiagainst): generate these strings using ODS.
   auto *op = varOp.getOperation();
-  auto descriptorSetName =
-      convertToSnakeCase(stringifyDecoration(spirv::Decoration::DescriptorSet));
-  auto bindingName =
-      convertToSnakeCase(stringifyDecoration(spirv::Decoration::Binding));
-  auto builtInName =
-      convertToSnakeCase(stringifyDecoration(spirv::Decoration::BuiltIn));
+  auto descriptorSetName = llvm::convertToSnakeFromCamelCase(
+      stringifyDecoration(spirv::Decoration::DescriptorSet));
+  auto bindingName = llvm::convertToSnakeFromCamelCase(
+      stringifyDecoration(spirv::Decoration::Binding));
+  auto builtInName = llvm::convertToSnakeFromCamelCase(
+      stringifyDecoration(spirv::Decoration::BuiltIn));
 
   for (const auto &attr : {descriptorSetName, bindingName, builtInName}) {
     if (op->getAttr(attr))
       return varOp.emitOpError("cannot have '")
              << attr << "' attribute (only allowed in spv.globalVariable)";
   }
 
   return success();

mlir/lib/Dialect/SPIRV/Serialization/Deserializer.cpp

 #include "mlir/Dialect/SPIRV/SPIRVAttributes.h"
 #include "mlir/Dialect/SPIRV/SPIRVBinaryUtils.h"
 #include "mlir/Dialect/SPIRV/SPIRVOps.h"
 #include "mlir/Dialect/SPIRV/SPIRVTypes.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Location.h"
 #include "mlir/Support/LogicalResult.h"
-#include "mlir/Support/StringExtras.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/bit.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace mlir;
 
 #define DEBUG_TYPE "spirv-deserialization"
 
if (words.size() < 2) {
     return emitError(
         unknownLoc, "OpDecorate must have at least result <id> and Decoration");
   }
   auto decorationName =
       stringifyDecoration(static_cast<spirv::Decoration>(words[1]));
   if (decorationName.empty()) {
     return emitError(unknownLoc, "invalid Decoration code : ") << words[1];
   }
-  auto attrName = convertToSnakeCase(decorationName);
+  auto attrName = llvm::convertToSnakeFromCamelCase(decorationName);
   auto symbol = opBuilder.getIdentifier(attrName);
   switch (static_cast<spirv::Decoration>(words[1])) {
   case spirv::Decoration::DescriptorSet:
   case spirv::Decoration::Binding:
     if (words.size() != 3) {
       return emitError(unknownLoc, "OpDecorate with ")
              << decorationName << " needs a single integer literal";
     }

mlir/lib/Dialect/SPIRV/Serialization/Serializer.cpp

 #include "mlir/Dialect/SPIRV/SPIRVAttributes.h"
 #include "mlir/Dialect/SPIRV/SPIRVBinaryUtils.h"
 #include "mlir/Dialect/SPIRV/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/SPIRVOps.h"
 #include "mlir/Dialect/SPIRV/SPIRVTypes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/RegionGraphTraits.h"
 #include "mlir/Support/LogicalResult.h"
-#include "mlir/Support/StringExtras.h"
 #include "llvm/ADT/DepthFirstIterator.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/ADT/bit.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 #define DEBUG_TYPE "spirv-serialization"
 
 using namespace mlir;
LogicalResult Serializer::processUndefOp(spirv::UndefOp op) {
   }
   valueIDMap[op.getResult()] = id;
   return success();
 }
 
 LogicalResult Serializer::processDecoration(Location loc, uint32_t resultID,
                                             NamedAttribute attr) {
   auto attrName = attr.first.strref();
-  auto decorationName = mlir::convertToCamelCase(attrName, true);
+  auto decorationName = llvm::convertToCamelFromSnakeCase(attrName, true);
   auto decoration = spirv::symbolizeDecoration(decorationName);
   if (!decoration) {
     return emitError(
                loc, "non-argument attributes expected to have snake-case-ified "
                     "decoration name, unhandled attribute with name : ")
            << attrName;
   }
   SmallVector<uint32_t, 1> args;

mlir/tools/mlir-tblgen/DialectGen.cpp

 //===- DialectGen.cpp - MLIR dialect definitions generator ----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // DialectGen uses the description of dialects to generate C++ definitions.
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Support/StringExtras.h"
 #include "mlir/TableGen/Format.h"
 #include "mlir/TableGen/GenInfo.h"
 #include "mlir/TableGen/OpClass.h"
 #include "mlir/TableGen/OpInterfaces.h"
 #include "mlir/TableGen/OpTrait.h"
 #include "mlir/TableGen/Operator.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/StringExtras.h"

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 //===- OpDefinitionsGen.cpp - MLIR op definitions generator ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // OpDefinitionsGen uses the description of operations to generate C++
 // definitions for ops.
 //
 //===----------------------------------------------------------------------===//
 
 #include "OpFormatGen.h"
-#include "mlir/Support/StringExtras.h"
 #include "mlir/TableGen/Format.h"
 #include "mlir/TableGen/GenInfo.h"
 #include "mlir/TableGen/OpClass.h"
 #include "mlir/TableGen/OpInterfaces.h"
 #include "mlir/TableGen/OpTrait.h"
 #include "mlir/TableGen/Operator.h"
 #include "mlir/TableGen/SideEffects.h"
 #include "llvm/ADT/Sequence.h"

mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp

 //===- SPIRVSerializationGen.cpp - SPIR-V serialization utility generator -===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // SPIRVSerializationGen generates common utility functions for SPIR-V
 // serialization.
 //
 //===----------------------------------------------------------------------===//
 
-#include "mlir/Support/StringExtras.h"
 #include "mlir/TableGen/Attribute.h"
 #include "mlir/TableGen/Format.h"
 #include "mlir/TableGen/GenInfo.h"
 #include "mlir/TableGen/Operator.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"

 
 static void emitEnumGetAttrNameFnDefn(const EnumAttr &enumAttr,
                                       raw_ostream &os) {
   auto enumName = enumAttr.getEnumClassName();
   os << formatv("template <> inline StringRef attributeName<{0}>() {{\n",
                 enumName);
   os << "  "
      << formatv("static constexpr const char attrName[] = \"{0}\";\n",
-                mlir::convertToSnakeCase(enumName));
+                llvm::convertToSnakeFromCamelCase(enumName));
   os << "  return attrName;\n";
   os << "}\n";
 }
 
 static bool emitOpUtils(const RecordKeeper &recordKeeper, raw_ostream &os) {
   llvm::emitSourceFileHeader("SPIR-V Op Utilities", os);
 
   auto defs = recordKeeper.getAllDerivedDefinitions("EnumAttrInfo");

mlir/tools/mlir-vulkan-runner/VulkanRuntime.h

 
 #ifndef VULKAN_RUNTIME_H
 #define VULKAN_RUNTIME_H
 
 #include "mlir/Dialect/SPIRV/SPIRVOps.h"
 #include "mlir/Dialect/SPIRV/Serialization.h"
 #include "mlir/IR/Module.h"
 #include "mlir/Support/LogicalResult.h"
-#include "mlir/Support/StringExtras.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/ToolOutputFile.h"
 
 #include <vulkan/vulkan.h>
 
 using namespace mlir;
 
 using DescriptorSetIndex = uint32_t;
 using BindingIndex = uint32_t;

mlir/unittests/IR/CMakeLists.txt

 add_mlir_unittest(MLIRIRTests
   AttributeTest.cpp
   DialectTest.cpp
   OperationSupportTest.cpp
-  StringExtrasTest.cpp
 )
 target_link_libraries(MLIRIRTests
   PRIVATE
   MLIRIR)

mlir/unittests/IR/StringExtrasTest.cpp

-//===- StringExtrasTest.cpp - Tests for utility methods in StringExtras.h -===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "mlir/Support/StringExtras.h"
-#include "gtest/gtest.h"
-
-using namespace mlir;
-
-static void testConvertToSnakeCase(llvm::StringRef input,
-                                   llvm::StringRef expected) {
-  EXPECT_EQ(convertToSnakeCase(input), expected.str());
-}
-
-TEST(StringExtras, ConvertToSnakeCase) {
-  testConvertToSnakeCase("OpName", "op_name");
-  testConvertToSnakeCase("opName", "op_name");
-  testConvertToSnakeCase("_OpName", "_op_name");
-  testConvertToSnakeCase("Op_Name", "op_name");
-  testConvertToSnakeCase("", "");
-  testConvertToSnakeCase("A", "a");
-  testConvertToSnakeCase("_", "_");
-  testConvertToSnakeCase("a", "a");
-  testConvertToSnakeCase("op_name", "op_name");
-  testConvertToSnakeCase("_op_name", "_op_name");
-  testConvertToSnakeCase("__op_name", "__op_name");
-  testConvertToSnakeCase("op__name", "op__name");
-}
-
-template <bool capitalizeFirst>
-static void testConvertToCamelCase(llvm::StringRef input,
-                                   llvm::StringRef expected) {
-  EXPECT_EQ(convertToCamelCase(input, capitalizeFirst), expected.str());
-}
-
-TEST(StringExtras, ConvertToCamelCase) {
-  testConvertToCamelCase<false>("op_name", "opName");
-  testConvertToCamelCase<false>("_op_name", "_opName");
-  testConvertToCamelCase<false>("__op_name", "_OpName");
-  testConvertToCamelCase<false>("op__name", "op_Name");
-  testConvertToCamelCase<false>("", "");
-  testConvertToCamelCase<false>("A", "A");
-  testConvertToCamelCase<false>("_", "_");
-  testConvertToCamelCase<false>("a", "a");
-  testConvertToCamelCase<false>("OpName", "OpName");
-  testConvertToCamelCase<false>("opName", "opName");
-  testConvertToCamelCase<false>("_OpName", "_OpName");
-  testConvertToCamelCase<false>("Op_Name", "Op_Name");
-  testConvertToCamelCase<true>("op_name", "OpName");
-  testConvertToCamelCase<true>("_op_name", "_opName");
-  testConvertToCamelCase<true>("__op_name", "_OpName");
-  testConvertToCamelCase<true>("op__name", "Op_Name");
-  testConvertToCamelCase<true>("", "");
-  testConvertToCamelCase<true>("A", "A");
-  testConvertToCamelCase<true>("_", "_");
-  testConvertToCamelCase<true>("a", "A");
-  testConvertToCamelCase<true>("OpName", "OpName");
-  testConvertToCamelCase<true>("_OpName", "_OpName");
-  testConvertToCamelCase<true>("Op_Name", "Op_Name");
-  testConvertToCamelCase<true>("opName", "OpName");
-}