class SmallVectorImpl;
template <typename AllocatorTy>
class StringSet;
+template <typename T, typename R>
+class StringSwitch;
template <typename T>
class TinyPtrVector;
template <typename T, typename ResultT>
using llvm::SmallPtrSetImpl;
using llvm::SmallVector;
using llvm::SmallVectorImpl;
+template <typename T, typename R = T>
+using StringSwitch = llvm::StringSwitch<T, R>;
using llvm::TinyPtrVector;
template <typename T, typename ResultT = void>
using TypeSwitch = llvm::TypeSwitch<T, ResultT>;
unsigned indexBitwidth;
static dimension dimensionToIndex(Op op) {
- return llvm::StringSwitch<dimension>(op.dimension())
+ return StringSwitch<dimension>(op.dimension())
.Case("x", X)
.Case("y", Y)
.Case("z", Z)
if (failed(parser.parseKeyword(&key)))
return LLVMType();
- return llvm::StringSwitch<function_ref<LLVMType()>>(key)
+ return StringSwitch<function_ref<LLVMType()>>(key)
.Case("void", [&] { return LLVMVoidType::get(ctx); })
.Case("half", [&] { return LLVMHalfType::get(ctx); })
.Case("bfloat", [&] { return LLVMBFloatType::get(ctx); })
return Type();
Builder &builder = parser.getBuilder();
- Type result = llvm::StringSwitch<Type>(keyword)
+ Type result = StringSwitch<Type>(keyword)
.Case("attribute", builder.getType<AttributeType>())
.Case("operation", builder.getType<OperationType>())
.Case("type", builder.getType<TypeType>())
Error (*)(Options &, ModuleOp, StringRef,
std::function<llvm::Error(llvm::Module *)>);
auto compileAndExecuteFn =
- llvm::StringSwitch<CompileAndExecuteFnT>(options.mainFuncType.getValue())
+ StringSwitch<CompileAndExecuteFnT>(options.mainFuncType.getValue())
.Case("i32", compileAndExecuteSingleReturnFunction<int32_t>)
.Case("i64", compileAndExecuteSingleReturnFunction<int64_t>)
.Case("f32", compileAndExecuteSingleReturnFunction<float>)
return Visibility::Public;
// Otherwise, switch on the string value.
- return llvm::StringSwitch<Visibility>(vis.getValue())
+ return StringSwitch<Visibility>(vis.getValue())
.Case("private", Visibility::Private)
.Case("nested", Visibility::Nested)
.Case("public", Visibility::Public);
isAllDigit(spelling.drop_front(2))))
return Token(Token::inttype, spelling);
- Token::Kind kind = llvm::StringSwitch<Token::Kind>(spelling)
+ Token::Kind kind = StringSwitch<Token::Kind>(spelling)
#define TOK_KEYWORD(SPELLING) .Case(#SPELLING, Token::kw_##SPELLING)
#include "TokenKinds.def"
.Default(Token::bare_identifier);
}
FmtContext::PHKind FmtContext::getPlaceHolderKind(StringRef str) {
- return llvm::StringSwitch<FmtContext::PHKind>(str)
+ return StringSwitch<FmtContext::PHKind>(str)
.Case("_builder", FmtContext::PHKind::Builder)
.Case("_op", FmtContext::PHKind::Op)
.Case("_self", FmtContext::PHKind::Self)
return PredCombinerKind::Leaf;
const auto &combinedPred = static_cast<const CombinedPred &>(pred);
- return llvm::StringSwitch<PredCombinerKind>(
+ return StringSwitch<PredCombinerKind>(
combinedPred.getCombinerDef()->getName())
.Case("PredCombinerAnd", PredCombinerKind::And)
.Case("PredCombinerOr", PredCombinerKind::Or)
// Get the specific memory effect.
MemoryEffects::Effect *effect =
- llvm::StringSwitch<MemoryEffects::Effect *>(
+ StringSwitch<MemoryEffects::Effect *>(
effectElement.get("effect").cast<StringAttr>().getValue())
.Case("allocate", MemoryEffects::Allocate::get())
.Case("free", MemoryEffects::Free::get())
// Check to see if this identifier is a keyword.
StringRef str(tokStart, curPtr - tokStart);
- Token::Kind kind = llvm::StringSwitch<Token::Kind>(str)
+ Token::Kind kind = StringSwitch<Token::Kind>(str)
.Case("def", Token::Kind::kw_def)
.Case("ods_def", Token::Kind::kw_ods_def)
.Case("floordiv", Token::Kind::kw_floordiv)
body << "Keyword(\"" << value << "\")";
return;
}
- body << (StringRef)llvm::StringSwitch<StringRef>(value)
+ body << (StringRef)StringSwitch<StringRef>(value)
.Case("->", "Arrow()")
.Case(":", "Colon()")
.Case(",", "Comma()")
// Check to see if this identifier is a keyword.
StringRef str(tokStart, curPtr - tokStart);
Token::Kind kind =
- llvm::StringSwitch<Token::Kind>(str)
+ StringSwitch<Token::Kind>(str)
.Case("attr-dict", Token::kw_attr_dict)
.Case("attr-dict-with-keyword", Token::kw_attr_dict_w_keyword)
.Case("custom", Token::kw_custom)