[MLIR][NFC] Remove tblgen:: prefix in TableGen/*.cpp files

[jurahul]

Summary

• Add "using namespace mlir::tblgen" in several of the TableGen/*.cpp files and eliminate the tblgen::prefix to reduce code clutter.

mlir/include/mlir/TableGen/OpClass.h

enum Property {
     MP_Constructor = 0x2, // Constructor
     MP_Private = 0x4,     // Private method
   };
 
   OpMethod(StringRef retType, StringRef name, StringRef params,
            Property property, bool declOnly);
   virtual ~OpMethod() = default;
 
-  OpMethodBody &body();
+  OpMethodBody &body() { return methodBody; }
 
   // Returns true if this is a static method.
-  bool isStatic() const;
+  bool isStatic() const { return properties & MP_Static; }
 
   // Returns true if this is a private method.
-  bool isPrivate() const;
+  bool isPrivate() const { return properties & MP_Private; }
 
   // Writes the method as a declaration to the given `os`.
   virtual void writeDeclTo(raw_ostream &os) const;
   // Writes the method as a definition to the given `os`. `namePrefix` is the
   // prefix to be prepended to the method name (typically namespaces for
   // qualifying the method definition).
   virtual void writeDefTo(raw_ostream &os, StringRef namePrefix) const;
 

mlir/lib/TableGen/Argument.cpp

 //===- Argument.cpp - Argument definitions --------------------------------===//
 //
 // 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/TableGen/Argument.h"
 #include "llvm/TableGen/Record.h"
 
 using namespace mlir;
+using namespace mlir::tblgen;
 
-bool tblgen::NamedTypeConstraint::hasPredicate() const {
+bool NamedTypeConstraint::hasPredicate() const {
   return !constraint.getPredicate().isNull();
 }
 
-bool tblgen::NamedTypeConstraint::isOptional() const {
-  return constraint.isOptional();
-}
+bool NamedTypeConstraint::isOptional() const { return constraint.isOptional(); }
 
-bool tblgen::NamedTypeConstraint::isVariadic() const {
-  return constraint.isVariadic();
-}
+bool NamedTypeConstraint::isVariadic() const { return constraint.isVariadic(); }

mlir/lib/TableGen/Attribute.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/TableGen/Format.h"
 #include "mlir/TableGen/Operator.h"
 #include "llvm/TableGen/Record.h"
 
 using namespace mlir;
+using namespace mlir::tblgen;
 
 using llvm::CodeInit;
 using llvm::DefInit;
 using llvm::Init;
 using llvm::Record;
 using llvm::StringInit;
 
 // Returns the initializer's value as string if the given TableGen initializer
 // is a code or string initializer. Returns the empty StringRef otherwise.
 static StringRef getValueAsString(const Init *init) {
   if (const auto *code = dyn_cast<CodeInit>(init))
     return code->getValue().trim();
-  else if (const auto *str = dyn_cast<StringInit>(init))
+  if (const auto *str = dyn_cast<StringInit>(init))
     return str->getValue().trim();
   return {};
 }
 
-tblgen::AttrConstraint::AttrConstraint(const Record *record)
+AttrConstraint::AttrConstraint(const Record *record)
     : Constraint(Constraint::CK_Attr, record) {
   assert(isSubClassOf("AttrConstraint") &&
          "must be subclass of TableGen 'AttrConstraint' class");
 }
 
-bool tblgen::AttrConstraint::isSubClassOf(StringRef className) const {
+bool AttrConstraint::isSubClassOf(StringRef className) const {
   return def->isSubClassOf(className);
 }
 
-tblgen::Attribute::Attribute(const Record *record) : AttrConstraint(record) {
+Attribute::Attribute(const Record *record) : AttrConstraint(record) {
   assert(record->isSubClassOf("Attr") &&
          "must be subclass of TableGen 'Attr' class");
 }
 
-tblgen::Attribute::Attribute(const DefInit *init) : Attribute(init->getDef()) {}
+Attribute::Attribute(const DefInit *init) : Attribute(init->getDef()) {}
 
-bool tblgen::Attribute::isDerivedAttr() const {
-  return isSubClassOf("DerivedAttr");
-}
+bool Attribute::isDerivedAttr() const { return isSubClassOf("DerivedAttr"); }
 
-bool tblgen::Attribute::isTypeAttr() const {
-  return isSubClassOf("TypeAttrBase");
-}
+bool Attribute::isTypeAttr() const { return isSubClassOf("TypeAttrBase"); }
 
-bool tblgen::Attribute::isEnumAttr() const {
-  return isSubClassOf("EnumAttrInfo");
-}
+bool Attribute::isEnumAttr() const { return isSubClassOf("EnumAttrInfo"); }
 
-StringRef tblgen::Attribute::getStorageType() const {
+StringRef Attribute::getStorageType() const {
   const auto *init = def->getValueInit("storageType");
   auto type = getValueAsString(init);
   if (type.empty())
     return "Attribute";
   return type;
 }
 
-StringRef tblgen::Attribute::getReturnType() const {
+StringRef Attribute::getReturnType() const {
   const auto *init = def->getValueInit("returnType");
   return getValueAsString(init);
 }
 
 // Return the type constraint corresponding to the type of this attribute, or
 // None if this is not a TypedAttr.
-llvm::Optional<tblgen::Type> tblgen::Attribute::getValueType() const {
+llvm::Optional<Type> Attribute::getValueType() const {
   if (auto *defInit = dyn_cast<llvm::DefInit>(def->getValueInit("valueType")))
-    return tblgen::Type(defInit->getDef());
+    return Type(defInit->getDef());
   return llvm::None;
 }
 
-StringRef tblgen::Attribute::getConvertFromStorageCall() const {
+StringRef Attribute::getConvertFromStorageCall() const {
   const auto *init = def->getValueInit("convertFromStorage");
   return getValueAsString(init);
 }
 
-bool tblgen::Attribute::isConstBuildable() const {
+bool Attribute::isConstBuildable() const {
   const auto *init = def->getValueInit("constBuilderCall");
   return !getValueAsString(init).empty();
 }
 
-StringRef tblgen::Attribute::getConstBuilderTemplate() const {
+StringRef Attribute::getConstBuilderTemplate() const {
   const auto *init = def->getValueInit("constBuilderCall");
   return getValueAsString(init);
 }
 
-tblgen::Attribute tblgen::Attribute::getBaseAttr() const {
+Attribute Attribute::getBaseAttr() const {
   if (const auto *defInit =
           llvm::dyn_cast<llvm::DefInit>(def->getValueInit("baseAttr"))) {
     return Attribute(defInit).getBaseAttr();
   }
   return *this;
 }
 
-bool tblgen::Attribute::hasDefaultValue() const {
+bool Attribute::hasDefaultValue() const {
   const auto *init = def->getValueInit("defaultValue");
   return !getValueAsString(init).empty();
 }
 
-StringRef tblgen::Attribute::getDefaultValue() const {
+StringRef Attribute::getDefaultValue() const {
   const auto *init = def->getValueInit("defaultValue");
   return getValueAsString(init);
 }
 
-bool tblgen::Attribute::isOptional() const {
-  return def->getValueAsBit("isOptional");
-}
+bool Attribute::isOptional() const { return def->getValueAsBit("isOptional"); }
 
-StringRef tblgen::Attribute::getAttrDefName() const {
+StringRef Attribute::getAttrDefName() const {
   if (def->isAnonymous()) {
     return getBaseAttr().def->getName();
   }
   return def->getName();
 }
 
-StringRef tblgen::Attribute::getDerivedCodeBody() const {
+StringRef Attribute::getDerivedCodeBody() const {
   assert(isDerivedAttr() && "only derived attribute has 'body' field");
   return def->getValueAsString("body");
 }
 
-tblgen::Dialect tblgen::Attribute::getDialect() const {
+Dialect Attribute::getDialect() const {
   return Dialect(def->getValueAsDef("dialect"));
 }
 
-tblgen::ConstantAttr::ConstantAttr(const DefInit *init) : def(init->getDef()) {
+ConstantAttr::ConstantAttr(const DefInit *init) : def(init->getDef()) {
   assert(def->isSubClassOf("ConstantAttr") &&
          "must be subclass of TableGen 'ConstantAttr' class");
 }
 
-tblgen::Attribute tblgen::ConstantAttr::getAttribute() const {
+Attribute ConstantAttr::getAttribute() const {
   return Attribute(def->getValueAsDef("attr"));
 }
 
-StringRef tblgen::ConstantAttr::getConstantValue() const {
+StringRef ConstantAttr::getConstantValue() const {
   return def->getValueAsString("value");
 }
 
-tblgen::EnumAttrCase::EnumAttrCase(const llvm::Record *record)
-    : Attribute(record) {
+EnumAttrCase::EnumAttrCase(const llvm::Record *record) : Attribute(record) {
   assert(isSubClassOf("EnumAttrCaseInfo") &&
          "must be subclass of TableGen 'EnumAttrInfo' class");
 }
 
-tblgen::EnumAttrCase::EnumAttrCase(const llvm::DefInit *init)
+EnumAttrCase::EnumAttrCase(const llvm::DefInit *init)
     : EnumAttrCase(init->getDef()) {}
 
-bool tblgen::EnumAttrCase::isStrCase() const {
-  return isSubClassOf("StrEnumAttrCase");
-}
+bool EnumAttrCase::isStrCase() const { return isSubClassOf("StrEnumAttrCase"); }
 
-StringRef tblgen::EnumAttrCase::getSymbol() const {
+StringRef EnumAttrCase::getSymbol() const {
   return def->getValueAsString("symbol");
 }
 
-StringRef tblgen::EnumAttrCase::getStr() const {
-  return def->getValueAsString("str");
-}
+StringRef EnumAttrCase::getStr() const { return def->getValueAsString("str"); }
 
-int64_t tblgen::EnumAttrCase::getValue() const {
-  return def->getValueAsInt("value");
-}
+int64_t EnumAttrCase::getValue() const { return def->getValueAsInt("value"); }
 
-const llvm::Record &tblgen::EnumAttrCase::getDef() const { return *def; }
+const llvm::Record &EnumAttrCase::getDef() const { return *def; }
 
-tblgen::EnumAttr::EnumAttr(const llvm::Record *record) : Attribute(record) {
+EnumAttr::EnumAttr(const llvm::Record *record) : Attribute(record) {
   assert(isSubClassOf("EnumAttrInfo") &&
          "must be subclass of TableGen 'EnumAttr' class");
 }
 
-tblgen::EnumAttr::EnumAttr(const llvm::Record &record) : Attribute(&record) {}
+EnumAttr::EnumAttr(const llvm::Record &record) : Attribute(&record) {}
 
-tblgen::EnumAttr::EnumAttr(const llvm::DefInit *init)
-    : EnumAttr(init->getDef()) {}
+EnumAttr::EnumAttr(const llvm::DefInit *init) : EnumAttr(init->getDef()) {}
 
-bool tblgen::EnumAttr::classof(const Attribute *attr) {
+bool EnumAttr::classof(const Attribute *attr) {
   return attr->isSubClassOf("EnumAttrInfo");
 }
 
-bool tblgen::EnumAttr::isBitEnum() const { return isSubClassOf("BitEnumAttr"); }
+bool EnumAttr::isBitEnum() const { return isSubClassOf("BitEnumAttr"); }
 
-StringRef tblgen::EnumAttr::getEnumClassName() const {
+StringRef EnumAttr::getEnumClassName() const {
   return def->getValueAsString("className");
 }
 
-StringRef tblgen::EnumAttr::getCppNamespace() const {
+StringRef EnumAttr::getCppNamespace() const {
   return def->getValueAsString("cppNamespace");
 }
 
-StringRef tblgen::EnumAttr::getUnderlyingType() const {
+StringRef EnumAttr::getUnderlyingType() const {
   return def->getValueAsString("underlyingType");
 }
 
-StringRef tblgen::EnumAttr::getUnderlyingToSymbolFnName() const {
+StringRef EnumAttr::getUnderlyingToSymbolFnName() const {
   return def->getValueAsString("underlyingToSymbolFnName");
 }
 
-StringRef tblgen::EnumAttr::getStringToSymbolFnName() const {
+StringRef EnumAttr::getStringToSymbolFnName() const {
   return def->getValueAsString("stringToSymbolFnName");
 }
 
-StringRef tblgen::EnumAttr::getSymbolToStringFnName() const {
+StringRef EnumAttr::getSymbolToStringFnName() const {
   return def->getValueAsString("symbolToStringFnName");
 }
 
-StringRef tblgen::EnumAttr::getSymbolToStringFnRetType() const {
+StringRef EnumAttr::getSymbolToStringFnRetType() const {
   return def->getValueAsString("symbolToStringFnRetType");
 }
 
-StringRef tblgen::EnumAttr::getMaxEnumValFnName() const {
+StringRef EnumAttr::getMaxEnumValFnName() const {
   return def->getValueAsString("maxEnumValFnName");
 }
 
-std::vector<tblgen::EnumAttrCase> tblgen::EnumAttr::getAllCases() const {
+std::vector<EnumAttrCase> EnumAttr::getAllCases() const {
   const auto *inits = def->getValueAsListInit("enumerants");
 
-  std::vector<tblgen::EnumAttrCase> cases;
+  std::vector<EnumAttrCase> cases;
   cases.reserve(inits->size());
 
   for (const llvm::Init *init : *inits) {
-    cases.push_back(tblgen::EnumAttrCase(cast<llvm::DefInit>(init)));
+    cases.push_back(EnumAttrCase(cast<llvm::DefInit>(init)));
   }
 
   return cases;
 }
 
-tblgen::StructFieldAttr::StructFieldAttr(const llvm::Record *record)
-    : def(record) {
+StructFieldAttr::StructFieldAttr(const llvm::Record *record) : def(record) {
   assert(def->isSubClassOf("StructFieldAttr") &&
          "must be subclass of TableGen 'StructFieldAttr' class");
 }
 
-tblgen::StructFieldAttr::StructFieldAttr(const llvm::Record &record)
+StructFieldAttr::StructFieldAttr(const llvm::Record &record)
     : StructFieldAttr(&record) {}
 
-tblgen::StructFieldAttr::StructFieldAttr(const llvm::DefInit *init)
+StructFieldAttr::StructFieldAttr(const llvm::DefInit *init)
     : StructFieldAttr(init->getDef()) {}
 
-StringRef tblgen::StructFieldAttr::getName() const {
+StringRef StructFieldAttr::getName() const {
   return def->getValueAsString("name");
 }
 
-tblgen::Attribute tblgen::StructFieldAttr::getType() const {
+Attribute StructFieldAttr::getType() const {
   auto init = def->getValueInit("type");
-  return tblgen::Attribute(cast<llvm::DefInit>(init));
+  return Attribute(cast<llvm::DefInit>(init));
 }
 
-tblgen::StructAttr::StructAttr(const llvm::Record *record) : Attribute(record) {
+StructAttr::StructAttr(const llvm::Record *record) : Attribute(record) {
   assert(isSubClassOf("StructAttr") &&
          "must be subclass of TableGen 'StructAttr' class");
 }
 
-tblgen::StructAttr::StructAttr(const llvm::DefInit *init)
+StructAttr::StructAttr(const llvm::DefInit *init)
     : StructAttr(init->getDef()) {}
 
-StringRef tblgen::StructAttr::getStructClassName() const {
+StringRef StructAttr::getStructClassName() const {
   return def->getValueAsString("className");
 }
 
-StringRef tblgen::StructAttr::getCppNamespace() const {
+StringRef StructAttr::getCppNamespace() const {
   Dialect dialect(def->getValueAsDef("structDialect"));
   return dialect.getCppNamespace();
 }
 
-std::vector<mlir::tblgen::StructFieldAttr>
-tblgen::StructAttr::getAllFields() const {
-  std::vector<mlir::tblgen::StructFieldAttr> attributes;
+std::vector<StructFieldAttr> StructAttr::getAllFields() const {
+  std::vector<StructFieldAttr> attributes;
 
   const auto *inits = def->getValueAsListInit("fields");
   attributes.reserve(inits->size());
 
   for (const llvm::Init *init : *inits) {
     attributes.emplace_back(cast<llvm::DefInit>(init));
   }
 
   return attributes;
 }
 
-const char *mlir::tblgen::inferTypeOpInterface = "InferTypeOpInterface";
+const char * ::mlir::tblgen::inferTypeOpInterface = "InferTypeOpInterface";

mlir/lib/TableGen/Dialect.cpp

 //===- Dialect.cpp - Dialect wrapper class --------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Dialect wrapper to simplify using TableGen Record defining a MLIR dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/TableGen/Dialect.h"
 #include "llvm/TableGen/Record.h"
 
-namespace mlir {
-namespace tblgen {
+using namespace mlir;
+using namespace mlir::tblgen;
 
-StringRef tblgen::Dialect::getName() const {
-  return def->getValueAsString("name");
-}
+StringRef Dialect::getName() const { return def->getValueAsString("name"); }
 
-StringRef tblgen::Dialect::getCppNamespace() const {
+StringRef Dialect::getCppNamespace() const {
   return def->getValueAsString("cppNamespace");
 }
 
-std::string tblgen::Dialect::getCppClassName() const {
+std::string Dialect::getCppClassName() const {
   // Simply use the name and remove any '_' tokens.
   std::string cppName = def->getName().str();
   llvm::erase_if(cppName, [](char c) { return c == '_'; });
   return cppName;
 }
 
 static StringRef getAsStringOrEmpty(const llvm::Record &record,
                                     StringRef fieldName) {
   if (auto valueInit = record.getValueInit(fieldName)) {
     if (llvm::isa<llvm::CodeInit, llvm::StringInit>(valueInit))
       return record.getValueAsString(fieldName);
   }
   return "";
 }
 
-StringRef tblgen::Dialect::getSummary() const {
+StringRef Dialect::getSummary() const {
   return getAsStringOrEmpty(*def, "summary");
 }
 
-StringRef tblgen::Dialect::getDescription() const {
+StringRef Dialect::getDescription() const {
   return getAsStringOrEmpty(*def, "description");
 }
 
-llvm::Optional<StringRef> tblgen::Dialect::getExtraClassDeclaration() const {
+llvm::Optional<StringRef> Dialect::getExtraClassDeclaration() const {
   auto value = def->getValueAsString("extraClassDeclaration");
   return value.empty() ? llvm::Optional<StringRef>() : value;
 }
 
-bool tblgen::Dialect::hasConstantMaterializer() const {
+bool Dialect::hasConstantMaterializer() const {
   return def->getValueAsBit("hasConstantMaterializer");
 }
 
-bool tblgen::Dialect::hasOperationAttrVerify() const {
+bool Dialect::hasOperationAttrVerify() const {
   return def->getValueAsBit("hasOperationAttrVerify");
 }
 
-bool tblgen::Dialect::hasRegionArgAttrVerify() const {
+bool Dialect::hasRegionArgAttrVerify() const {
   return def->getValueAsBit("hasRegionArgAttrVerify");
 }
 
-bool tblgen::Dialect::hasRegionResultAttrVerify() const {
+bool Dialect::hasRegionResultAttrVerify() const {
   return def->getValueAsBit("hasRegionResultAttrVerify");
 }
 
 bool Dialect::operator==(const Dialect &other) const {
   return def == other.def;
 }
 
 bool Dialect::operator<(const Dialect &other) const {
   return getName() < other.getName();
 }
-
-} // end namespace tblgen
-} // end namespace mlir

mlir/lib/TableGen/Format.cpp

 #include <cctype>
 
 using namespace mlir;
 using namespace mlir::tblgen;
 
 // Marker to indicate an error happened when replacing a placeholder.
 const char *const kMarkerForNoSubst = "<no-subst-found>";
 
-FmtContext &tblgen::FmtContext::addSubst(StringRef placeholder, Twine subst) {
+FmtContext &FmtContext::addSubst(StringRef placeholder, Twine subst) {
   customSubstMap[placeholder] = subst.str();
   return *this;
 }
 
-FmtContext &tblgen::FmtContext::withBuilder(Twine subst) {
+FmtContext &FmtContext::withBuilder(Twine subst) {
   builtinSubstMap[PHKind::Builder] = subst.str();
   return *this;
 }
 
-FmtContext &tblgen::FmtContext::withOp(Twine subst) {
+FmtContext &FmtContext::withOp(Twine subst) {
   builtinSubstMap[PHKind::Op] = subst.str();
   return *this;
 }
 
-FmtContext &tblgen::FmtContext::withSelf(Twine subst) {
+FmtContext &FmtContext::withSelf(Twine subst) {
   builtinSubstMap[PHKind::Self] = subst.str();
   return *this;
 }
 
 Optional<StringRef>
-tblgen::FmtContext::getSubstFor(FmtContext::PHKind placeholder) const {
+FmtContext::getSubstFor(FmtContext::PHKind placeholder) const {
   if (placeholder == FmtContext::PHKind::None ||
       placeholder == FmtContext::PHKind::Custom)
     return {};
   auto it = builtinSubstMap.find(placeholder);
   if (it == builtinSubstMap.end())
     return {};
   return StringRef(it->second);
 }
 
-Optional<StringRef>
-tblgen::FmtContext::getSubstFor(StringRef placeholder) const {
+Optional<StringRef> FmtContext::getSubstFor(StringRef placeholder) const {
   auto it = customSubstMap.find(placeholder);
   if (it == customSubstMap.end())
     return {};
   return StringRef(it->second);
 }
 
-FmtContext::PHKind tblgen::FmtContext::getPlaceHolderKind(StringRef str) {
+FmtContext::PHKind FmtContext::getPlaceHolderKind(StringRef str) {
   return llvm::StringSwitch<FmtContext::PHKind>(str)
       .Case("_builder", FmtContext::PHKind::Builder)
       .Case("_op", FmtContext::PHKind::Op)
       .Case("_self", FmtContext::PHKind::Self)
       .Case("", FmtContext::PHKind::None)
       .Default(FmtContext::PHKind::Custom);
 }
 
 std::pair<FmtReplacement, StringRef>
-tblgen::FmtObjectBase::splitFmtSegment(StringRef fmt) {
+FmtObjectBase::splitFmtSegment(StringRef fmt) {
   size_t begin = fmt.find_first_of('$');
   if (begin == StringRef::npos) {
     // No placeholders: the whole format string should be returned as a
     // literal string.
     return {FmtReplacement{fmt}, StringRef()};
   }
   if (begin != 0) {
     // The first placeholder is not at the beginning: we can split the format

mlir/lib/TableGen/OpClass.cpp

 //===- OpClass.cpp - Helper classes for Op C++ code emission --------------===//
 //
 // 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/TableGen/OpClass.h"
 
 #include "mlir/TableGen/Format.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace mlir;
+using namespace mlir::tblgen;
 
 //===----------------------------------------------------------------------===//
 // OpMethodSignature definitions
 //===----------------------------------------------------------------------===//
 
-tblgen::OpMethodSignature::OpMethodSignature(StringRef retType, StringRef name,
-                                             StringRef params)
+OpMethodSignature::OpMethodSignature(StringRef retType, StringRef name,
     : returnType(retType), methodName(name), parameters(params) {}
 
-void tblgen::OpMethodSignature::writeDeclTo(raw_ostream &os) const {
+void OpMethodSignature::writeDeclTo(raw_ostream &os) const {
   os << returnType << (elideSpaceAfterType(returnType) ? "" : " ") << methodName
      << "(" << parameters << ")";
 }
 
-void tblgen::OpMethodSignature::writeDefTo(raw_ostream &os,
-                                           StringRef namePrefix) const {
+void OpMethodSignature::writeDefTo(raw_ostream &os,
   // We need to remove the default values for parameters in method definition.
   // TODO: We are using '=' and ',' as delimiters for parameter
   // initializers. This is incorrect for initializer list with more than one
   // element. Change to a more robust approach.
   auto removeParamDefaultValue = [](StringRef params) {
     std::string result;
     std::pair<StringRef, StringRef> parts;
     while (!params.empty()) {
       parts = params.split("=");
       result.append(result.empty() ? "" : ", ");
       result += parts.first;
       params = parts.second.split(",").second;
     }
     return result;
   };
 
   os << returnType << (elideSpaceAfterType(returnType) ? "" : " ") << namePrefix
      << (namePrefix.empty() ? "" : "::") << methodName << "("
      << removeParamDefaultValue(parameters) << ")";
 }
 
-bool tblgen::OpMethodSignature::elideSpaceAfterType(StringRef type) {
+bool OpMethodSignature::elideSpaceAfterType(StringRef type) {
   return type.empty() || type.endswith("&") || type.endswith("*");
 }
 
 //===----------------------------------------------------------------------===//
 // OpMethodBody definitions
 //===----------------------------------------------------------------------===//
 
-tblgen::OpMethodBody::OpMethodBody(bool declOnly) : isEffective(!declOnly) {}
+OpMethodBody::OpMethodBody(bool declOnly) : isEffective(!declOnly) {}
 
-tblgen::OpMethodBody &tblgen::OpMethodBody::operator<<(Twine content) {
+OpMethodBody &OpMethodBody::operator<<(Twine content) {
   if (isEffective)
     body.append(content.str());
   return *this;
 }
 
-tblgen::OpMethodBody &tblgen::OpMethodBody::operator<<(int content) {
+OpMethodBody &OpMethodBody::operator<<(int content) {
   if (isEffective)
     body.append(std::to_string(content));
   return *this;
 }
 
-tblgen::OpMethodBody &
-tblgen::OpMethodBody::operator<<(const FmtObjectBase &content) {
+OpMethodBody &OpMethodBody::operator<<(const FmtObjectBase &content) {
   if (isEffective)
     body.append(content.str());
   return *this;
 }
 
-void tblgen::OpMethodBody::writeTo(raw_ostream &os) const {
+void OpMethodBody::writeTo(raw_ostream &os) const {
   auto bodyRef = StringRef(body).drop_while([](char c) { return c == '\n'; });
   os << bodyRef;
   if (bodyRef.empty() || bodyRef.back() != '\n')
     os << "\n";
 }
 
 //===----------------------------------------------------------------------===//
 // OpMethod definitions
 //===----------------------------------------------------------------------===//
 
-tblgen::OpMethod::OpMethod(StringRef retType, StringRef name, StringRef params,
-                           OpMethod::Property property, bool declOnly)
+OpMethod::OpMethod(StringRef retType, StringRef name, StringRef params,
     : properties(property), isDeclOnly(declOnly),
       methodSignature(retType, name, params), methodBody(declOnly) {}
-
-tblgen::OpMethodBody &tblgen::OpMethod::body() { return methodBody; }
-
-bool tblgen::OpMethod::isStatic() const { return properties & MP_Static; }
-
-bool tblgen::OpMethod::isPrivate() const { return properties & MP_Private; }
-
-void tblgen::OpMethod::writeDeclTo(raw_ostream &os) const {
+void OpMethod::writeDeclTo(raw_ostream &os) const {
   os.indent(2);
   if (isStatic())
     os << "static ";
   methodSignature.writeDeclTo(os);
   os << ";";
 }
 
-void tblgen::OpMethod::writeDefTo(raw_ostream &os, StringRef namePrefix) const {
+void OpMethod::writeDefTo(raw_ostream &os, StringRef namePrefix) const {
   if (isDeclOnly)
     return;
 
   methodSignature.writeDefTo(os, namePrefix);
   os << " {\n";
   methodBody.writeTo(os);
   os << "}";
 }
 
 //===----------------------------------------------------------------------===//
 // OpConstructor definitions
 //===----------------------------------------------------------------------===//
 
-void mlir::tblgen::OpConstructor::addMemberInitializer(StringRef name,
-                                                       StringRef value) {
+void OpConstructor::addMemberInitializer(StringRef name, StringRef value) {
   memberInitializers.append(std::string(llvm::formatv(
       "{0}{1}({2})", memberInitializers.empty() ? " : " : ", ", name, value)));
 }
 
-void mlir::tblgen::OpConstructor::writeDefTo(raw_ostream &os,
-                                             StringRef namePrefix) const {
+void OpConstructor::writeDefTo(raw_ostream &os, StringRef namePrefix) const {
   if (isDeclOnly)
     return;
 
   methodSignature.writeDefTo(os, namePrefix);
   os << " " << memberInitializers << " {\n";
   methodBody.writeTo(os);
   os << "}";
 }
 
 //===----------------------------------------------------------------------===//
 // Class definitions
 //===----------------------------------------------------------------------===//
 
-tblgen::Class::Class(StringRef name) : className(name) {}
+Class::Class(StringRef name) : className(name) {}
 
-tblgen::OpMethod &tblgen::Class::newMethod(StringRef retType, StringRef name,
-                                           StringRef params,
-                                           OpMethod::Property property,
-                                           bool declOnly) {
+OpMethod &Class::newMethod(StringRef retType, StringRef name, StringRef params,
+                           OpMethod::Property property, bool declOnly) {
   methods.emplace_back(retType, name, params, property, declOnly);
   return methods.back();
 }
 
-tblgen::OpConstructor &tblgen::Class::newConstructor(StringRef params,
-                                                     bool declOnly) {
+OpConstructor &Class::newConstructor(StringRef params, bool declOnly) {
   constructors.emplace_back("", getClassName(), params,
                             OpMethod::MP_Constructor, declOnly);
   return constructors.back();
 }
 
-void tblgen::Class::newField(StringRef type, StringRef name,
-                             StringRef defaultValue) {
+void Class::newField(StringRef type, StringRef name, StringRef defaultValue) {
   std::string varName = formatv("{0} {1}", type, name).str();
   std::string field = defaultValue.empty()
                           ? varName
                           : formatv("{0} = {1}", varName, defaultValue).str();
   fields.push_back(std::move(field));
 }
 
-void tblgen::Class::writeDeclTo(raw_ostream &os) const {
+void Class::writeDeclTo(raw_ostream &os) const {
   bool hasPrivateMethod = false;
   os << "class " << className << " {\n";
   os << "public:\n";
   for (const auto &method :
        llvm::concat<const OpMethod>(constructors, methods)) {
     if (!method.isPrivate()) {
       method.writeDeclTo(os);
       os << '\n';
if (hasPrivateMethod) {
     }
     os << '\n';
   }
   for (const auto &field : fields)
     os.indent(2) << field << ";\n";
   os << "};\n";
 }
 
-void tblgen::Class::writeDefTo(raw_ostream &os) const {
+void Class::writeDefTo(raw_ostream &os) const {
   for (const auto &method :
        llvm::concat<const OpMethod>(constructors, methods)) {
     method.writeDefTo(os, className);
     os << "\n\n";
   }
 }
 
 //===----------------------------------------------------------------------===//
 // OpClass definitions
 //===----------------------------------------------------------------------===//
 
-tblgen::OpClass::OpClass(StringRef name, StringRef extraClassDeclaration)
+OpClass::OpClass(StringRef name, StringRef extraClassDeclaration)
     : Class(name), extraClassDeclaration(extraClassDeclaration) {}
 
-void tblgen::OpClass::addTrait(Twine trait) {
+void OpClass::addTrait(Twine trait) {
   auto traitStr = trait.str();
   if (traitsSet.insert(traitStr).second)
     traitsVec.push_back(std::move(traitStr));
 }
 
-void tblgen::OpClass::writeDeclTo(raw_ostream &os) const {
+void OpClass::writeDeclTo(raw_ostream &os) const {
   os << "class " << className << " : public ::mlir::Op<" << className;
   for (const auto &trait : traitsVec)
     os << ", " << trait;
   os << "> {\npublic:\n";
   os << "  using Op::Op;\n";
   os << "  using Adaptor = " << className << "Adaptor;\n";
 
   bool hasPrivateMethod = false;

mlir/lib/TableGen/OpTrait.cpp

llvm::StringRef NativeOpTrait::getTrait() const {
   return def->getValueAsString("trait");
 }
 
 llvm::StringRef InternalOpTrait::getTrait() const {
   return def->getValueAsString("trait");
 }
 
 std::string PredOpTrait::getPredTemplate() const {
-  auto pred = tblgen::Pred(def->getValueInit("predicate"));
+  auto pred = Pred(def->getValueInit("predicate"));
   return pred.getCondition();
 }
 
 llvm::StringRef PredOpTrait::getDescription() const {
   return def->getValueAsString("description");
 }
 
 OpInterface InterfaceOpTrait::getOpInterface() const {

mlir/lib/TableGen/Operator.cpp

 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 
 #define DEBUG_TYPE "mlir-tblgen-operator"
 
 using namespace mlir;
+using namespace mlir::tblgen;
 
 using llvm::DagInit;
 using llvm::DefInit;
 using llvm::Record;
 
-tblgen::Operator::Operator(const llvm::Record &def)
+Operator::Operator(const llvm::Record &def)
     : dialect(def.getValueAsDef("opDialect")), def(def) {
   // The first `_` in the op's TableGen def name is treated as separating the
   // dialect prefix and the op class name. The dialect prefix will be ignored if
   // not empty. Otherwise, if def name starts with a `_`, the `_` is considered
   // as part of the class name.
   StringRef prefix;
   std::tie(prefix, cppClassName) = def.getName().split('_');
   if (prefix.empty()) {
     // Class name with a leading underscore and without dialect prefix
     cppClassName = def.getName();
   } else if (cppClassName.empty()) {
     // Class name without dialect prefix
     cppClassName = prefix;
   }
 
   populateOpStructure();
 }
 
-std::string tblgen::Operator::getOperationName() const {
+std::string Operator::getOperationName() const {
   auto prefix = dialect.getName();
   auto opName = def.getValueAsString("opName");
   if (prefix.empty())
     return std::string(opName);
   return std::string(llvm::formatv("{0}.{1}", prefix, opName));
 }
 
-std::string tblgen::Operator::getAdaptorName() const {
+std::string Operator::getAdaptorName() const {
   return std::string(llvm::formatv("{0}Adaptor", getCppClassName()));
 }
 
-StringRef tblgen::Operator::getDialectName() const { return dialect.getName(); }
+StringRef Operator::getDialectName() const { return dialect.getName(); }
 
-StringRef tblgen::Operator::getCppClassName() const { return cppClassName; }
+StringRef Operator::getCppClassName() const { return cppClassName; }
 
-std::string tblgen::Operator::getQualCppClassName() const {
+std::string Operator::getQualCppClassName() const {
   auto prefix = dialect.getCppNamespace();
   if (prefix.empty())
     return std::string(cppClassName);
   return std::string(llvm::formatv("{0}::{1}", prefix, cppClassName));
 }
 
-int tblgen::Operator::getNumResults() const {
+int Operator::getNumResults() const {
   DagInit *results = def.getValueAsDag("results");
   return results->getNumArgs();
 }
 
-StringRef tblgen::Operator::getExtraClassDeclaration() const {
+StringRef Operator::getExtraClassDeclaration() const {
   constexpr auto attr = "extraClassDeclaration";
   if (def.isValueUnset(attr))
     return {};
   return def.getValueAsString(attr);
 }
 
-const llvm::Record &tblgen::Operator::getDef() const { return def; }
+const llvm::Record &Operator::getDef() const { return def; }
 
-bool tblgen::Operator::skipDefaultBuilders() const {
+bool Operator::skipDefaultBuilders() const {
   return def.getValueAsBit("skipDefaultBuilders");
 }
 
-auto tblgen::Operator::result_begin() -> value_iterator {
-  return results.begin();
-}
+auto Operator::result_begin() -> value_iterator { return results.begin(); }
 
-auto tblgen::Operator::result_end() -> value_iterator { return results.end(); }
+auto Operator::result_end() -> value_iterator { return results.end(); }
 
-auto tblgen::Operator::getResults() -> value_range {
+auto Operator::getResults() -> value_range {
   return {result_begin(), result_end()};
 }
 
-tblgen::TypeConstraint
-tblgen::Operator::getResultTypeConstraint(int index) const {
+TypeConstraint Operator::getResultTypeConstraint(int index) const {
   DagInit *results = def.getValueAsDag("results");
   return TypeConstraint(cast<DefInit>(results->getArg(index)));
 }
 
-StringRef tblgen::Operator::getResultName(int index) const {
+StringRef Operator::getResultName(int index) const {
   DagInit *results = def.getValueAsDag("results");
   return results->getArgNameStr(index);
 }
 
-auto tblgen::Operator::getResultDecorators(int index) const
-    -> var_decorator_range {
+auto Operator::getResultDecorators(int index) const -> var_decorator_range {
   Record *result =
       cast<DefInit>(def.getValueAsDag("results")->getArg(index))->getDef();
   if (!result->isSubClassOf("OpVariable"))
     return var_decorator_range(nullptr, nullptr);
   return *result->getValueAsListInit("decorators");
 }
 
-unsigned tblgen::Operator::getNumVariableLengthResults() const {
+unsigned Operator::getNumVariableLengthResults() const {
   return llvm::count_if(results, [](const NamedTypeConstraint &c) {
     return c.constraint.isVariableLength();
   });
 }
 
-unsigned tblgen::Operator::getNumVariableLengthOperands() const {
+unsigned Operator::getNumVariableLengthOperands() const {
   return llvm::count_if(operands, [](const NamedTypeConstraint &c) {
     return c.constraint.isVariableLength();
   });
 }
 
-bool tblgen::Operator::hasSingleVariadicArg() const {
-  return getNumArgs() == 1 && getArg(0).is<tblgen::NamedTypeConstraint *>() &&
+bool Operator::hasSingleVariadicArg() const {
+  return getNumArgs() == 1 && getArg(0).is<NamedTypeConstraint *>() &&
          getOperand(0).isVariadic();
 }
 
-tblgen::Operator::arg_iterator tblgen::Operator::arg_begin() const {
-  return arguments.begin();
-}
+Operator::arg_iterator Operator::arg_begin() const { return arguments.begin(); }
 
-tblgen::Operator::arg_iterator tblgen::Operator::arg_end() const {
-  return arguments.end();
-}
+Operator::arg_iterator Operator::arg_end() const { return arguments.end(); }
 
-tblgen::Operator::arg_range tblgen::Operator::getArgs() const {
+Operator::arg_range Operator::getArgs() const {
   return {arg_begin(), arg_end()};
 }
 
-StringRef tblgen::Operator::getArgName(int index) const {
+StringRef Operator::getArgName(int index) const {
   DagInit *argumentValues = def.getValueAsDag("arguments");
   return argumentValues->getArgName(index)->getValue();
 }
 
-auto tblgen::Operator::getArgDecorators(int index) const
-    -> var_decorator_range {
+auto Operator::getArgDecorators(int index) const -> var_decorator_range {
   Record *arg =
       cast<DefInit>(def.getValueAsDag("arguments")->getArg(index))->getDef();
   if (!arg->isSubClassOf("OpVariable"))
     return var_decorator_range(nullptr, nullptr);
   return *arg->getValueAsListInit("decorators");
 }
 
-const tblgen::OpTrait *tblgen::Operator::getTrait(StringRef trait) const {
+const OpTrait *Operator::getTrait(StringRef trait) const {
   for (const auto &t : traits) {
-    if (const auto *opTrait = dyn_cast<tblgen::NativeOpTrait>(&t)) {
+    if (const auto *opTrait = dyn_cast<NativeOpTrait>(&t)) {
       if (opTrait->getTrait() == trait)
         return opTrait;
-    } else if (const auto *opTrait = dyn_cast<tblgen::InternalOpTrait>(&t)) {
+    } else if (const auto *opTrait = dyn_cast<InternalOpTrait>(&t)) {
       if (opTrait->getTrait() == trait)
         return opTrait;
-    } else if (const auto *opTrait = dyn_cast<tblgen::InterfaceOpTrait>(&t)) {
+    } else if (const auto *opTrait = dyn_cast<InterfaceOpTrait>(&t)) {
       if (opTrait->getTrait() == trait)
         return opTrait;
     }
   }
   return nullptr;
 }
 
-auto tblgen::Operator::region_begin() const -> const_region_iterator {
+auto Operator::region_begin() const -> const_region_iterator {
   return regions.begin();
 }
-auto tblgen::Operator::region_end() const -> const_region_iterator {
+auto Operator::region_end() const -> const_region_iterator {
   return regions.end();
 }
-auto tblgen::Operator::getRegions() const
+auto Operator::getRegions() const
     -> llvm::iterator_range<const_region_iterator> {
   return {region_begin(), region_end()};
 }
 
-unsigned tblgen::Operator::getNumRegions() const { return regions.size(); }
+unsigned Operator::getNumRegions() const { return regions.size(); }
 
-const tblgen::NamedRegion &tblgen::Operator::getRegion(unsigned index) const {
+const NamedRegion &Operator::getRegion(unsigned index) const {
   return regions[index];
 }
 
-unsigned tblgen::Operator::getNumVariadicRegions() const {
+unsigned Operator::getNumVariadicRegions() const {
   return llvm::count_if(regions,
                         [](const NamedRegion &c) { return c.isVariadic(); });
 }
 
-auto tblgen::Operator::successor_begin() const -> const_successor_iterator {
+auto Operator::successor_begin() const -> const_successor_iterator {
   return successors.begin();
 }
-auto tblgen::Operator::successor_end() const -> const_successor_iterator {
+auto Operator::successor_end() const -> const_successor_iterator {
   return successors.end();
 }
-auto tblgen::Operator::getSuccessors() const
+auto Operator::getSuccessors() const
     -> llvm::iterator_range<const_successor_iterator> {
   return {successor_begin(), successor_end()};
 }
 
-unsigned tblgen::Operator::getNumSuccessors() const {
-  return successors.size();
-}
+unsigned Operator::getNumSuccessors() const { return successors.size(); }
 
-const tblgen::NamedSuccessor &
-tblgen::Operator::getSuccessor(unsigned index) const {
+const NamedSuccessor &Operator::getSuccessor(unsigned index) const {
   return successors[index];
 }
 
-unsigned tblgen::Operator::getNumVariadicSuccessors() const {
+unsigned Operator::getNumVariadicSuccessors() const {
   return llvm::count_if(successors,
                         [](const NamedSuccessor &c) { return c.isVariadic(); });
 }
 
-auto tblgen::Operator::trait_begin() const -> const_trait_iterator {
+auto Operator::trait_begin() const -> const_trait_iterator {
   return traits.begin();
 }
-auto tblgen::Operator::trait_end() const -> const_trait_iterator {
+auto Operator::trait_end() const -> const_trait_iterator {
   return traits.end();
 }
-auto tblgen::Operator::getTraits() const
-    -> llvm::iterator_range<const_trait_iterator> {
+auto Operator::getTraits() const -> llvm::iterator_range<const_trait_iterator> {
   return {trait_begin(), trait_end()};
 }
 
-auto tblgen::Operator::attribute_begin() const -> attribute_iterator {
+auto Operator::attribute_begin() const -> attribute_iterator {
   return attributes.begin();
 }
-auto tblgen::Operator::attribute_end() const -> attribute_iterator {
+auto Operator::attribute_end() const -> attribute_iterator {
   return attributes.end();
 }
-auto tblgen::Operator::getAttributes() const
+auto Operator::getAttributes() const
     -> llvm::iterator_range<attribute_iterator> {
   return {attribute_begin(), attribute_end()};
 }
 
-auto tblgen::Operator::operand_begin() -> value_iterator {
-  return operands.begin();
-}
-auto tblgen::Operator::operand_end() -> value_iterator {
-  return operands.end();
-}
-auto tblgen::Operator::getOperands() -> value_range {
+auto Operator::operand_begin() -> value_iterator { return operands.begin(); }
+auto Operator::operand_end() -> value_iterator { return operands.end(); }
+auto Operator::getOperands() -> value_range {
   return {operand_begin(), operand_end()};
 }
 
-auto tblgen::Operator::getArg(int index) const -> Argument {
-  return arguments[index];
-}
+auto Operator::getArg(int index) const -> Argument { return arguments[index]; }
 
 // Mapping from result index to combined argument and result index. Arguments
 // are indexed to match getArg index, while the result indexes are mapped to
 // avoid overlap.
 static int resultIndex(int i) { return -1 - i; }
 
-bool tblgen::Operator::isVariadic() const {
+bool Operator::isVariadic() const {
   return any_of(llvm::concat<const NamedTypeConstraint>(operands, results),
                 [](const NamedTypeConstraint &op) { return op.isVariadic(); });
 }
 
-void tblgen::Operator::populateTypeInferenceInfo(
+void Operator::populateTypeInferenceInfo(
     const llvm::StringMap<int> &argumentsAndResultsIndex) {
   // If the type inference op interface is not registered, then do not attempt
   // to determine if the result types an be inferred.
   auto &recordKeeper = def.getRecords();
   auto *inferTrait = recordKeeper.getDef(inferTypeOpInterface);
   allResultsHaveKnownTypes = false;
   if (!inferTrait)
     return;
for (const OpTrait &trait : traits) {
     const llvm::Record &def = trait.getDef();
     // If the infer type op interface was manually added, then treat it as
     // intention that the op needs special handling.
     // TODO: Reconsider whether to always generate, this is more conservative
     // and keeps existing behavior so starting that way for now.
     if (def.isSubClassOf(
             llvm::formatv("{0}::Trait", inferTypeOpInterface).str()))
       return;
-    if (const auto *opTrait = dyn_cast<tblgen::InterfaceOpTrait>(&trait))
+    if (const auto *opTrait = dyn_cast<InterfaceOpTrait>(&trait))
       if (&opTrait->getDef() == inferTrait)
         return;
 
     if (!def.isSubClassOf("AllTypesMatch"))
       continue;
 
     auto values = def.getValueAsListOfStrings("values");
     auto root = argumentsAndResultsIndex.lookup(values.front());
     for (StringRef str : values)
       ecs.unionSets(argumentsAndResultsIndex.lookup(str), root);
   }
 
   // Verifies that all output types have a corresponding known input type
   // and chooses matching operand or attribute (in that order) that
   // matches it.
   allResultsHaveKnownTypes =
       all_of(llvm::seq<int>(0, getNumResults()), captureMapping);
 
   // If the types could be computed, then add type inference trait.
   if (allResultsHaveKnownTypes)
     traits.push_back(OpTrait::create(inferTrait->getDefInit()));
 }
 
-void tblgen::Operator::populateOpStructure() {
+void Operator::populateOpStructure() {
   auto &recordKeeper = def.getRecords();
   auto *typeConstraintClass = recordKeeper.getClass("TypeConstraint");
   auto *attrClass = recordKeeper.getClass("Attr");
   auto *derivedAttrClass = recordKeeper.getClass("DerivedAttr");
   auto *opVarClass = recordKeeper.getClass("OpVariable");
   numNativeAttributes = 0;
 
   DagInit *argumentValues = def.getValueAsDag("arguments");
for (unsigned i = 0, e = regionsDag->getNumArgs(); i < e; ++i) {
     }
 
     regions.push_back({name, region});
   }
 
   LLVM_DEBUG(print(llvm::dbgs()));
 }
 
-auto tblgen::Operator::getSameTypeAsResult(int index) const
-    -> ArrayRef<ArgOrType> {
+auto Operator::getSameTypeAsResult(int index) const -> ArrayRef<ArgOrType> {
   assert(allResultTypesKnown());
   return resultTypeMapping[index];
 }
 
-ArrayRef<llvm::SMLoc> tblgen::Operator::getLoc() const { return def.getLoc(); }
+ArrayRef<llvm::SMLoc> Operator::getLoc() const { return def.getLoc(); }
 
-bool tblgen::Operator::hasDescription() const {
+bool Operator::hasDescription() const {
   return def.getValue("description") != nullptr;
 }
 
-StringRef tblgen::Operator::getDescription() const {
+StringRef Operator::getDescription() const {
   return def.getValueAsString("description");
 }
 
-bool tblgen::Operator::hasSummary() const {
-  return def.getValue("summary") != nullptr;
-}
+bool Operator::hasSummary() const { return def.getValue("summary") != nullptr; }
 
-StringRef tblgen::Operator::getSummary() const {
+StringRef Operator::getSummary() const {
   return def.getValueAsString("summary");
 }
 
-bool tblgen::Operator::hasAssemblyFormat() const {
+bool Operator::hasAssemblyFormat() const {
   auto *valueInit = def.getValueInit("assemblyFormat");
   return isa<llvm::CodeInit, llvm::StringInit>(valueInit);
 }
 
-StringRef tblgen::Operator::getAssemblyFormat() const {
+StringRef Operator::getAssemblyFormat() const {
   return TypeSwitch<llvm::Init *, StringRef>(def.getValueInit("assemblyFormat"))
       .Case<llvm::StringInit, llvm::CodeInit>(
           [&](auto *init) { return init->getValue(); });
 }
 
-void tblgen::Operator::print(llvm::raw_ostream &os) const {
+void Operator::print(llvm::raw_ostream &os) const {
   os << "op '" << getOperationName() << "'\n";
   for (Argument arg : arguments) {
     if (auto *attr = arg.dyn_cast<NamedAttribute *>())
       os << "[attribute] " << attr->name << '\n';
     else
       os << "[operand] " << arg.get<NamedTypeConstraint *>()->name << '\n';
   }
 }
 
-auto tblgen::Operator::VariableDecoratorIterator::unwrap(llvm::Init *init)
+auto Operator::VariableDecoratorIterator::unwrap(llvm::Init *init)
     -> VariableDecorator {
   return VariableDecorator(cast<llvm::DefInit>(init)->getDef());
 }
 
-auto tblgen::Operator::getArgToOperandOrAttribute(int index) const
+auto Operator::getArgToOperandOrAttribute(int index) const
     -> OperandOrAttribute {
   return attrOrOperandMapping[index];
 }

mlir/lib/TableGen/Pattern.cpp

 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 
 #define DEBUG_TYPE "mlir-tblgen-pattern"
 
 using namespace mlir;
+using namespace tblgen;
 
 using llvm::formatv;
-using mlir::tblgen::Operator;
 
 //===----------------------------------------------------------------------===//
 // DagLeaf
 //===----------------------------------------------------------------------===//
 
-bool tblgen::DagLeaf::isUnspecified() const {
+bool DagLeaf::isUnspecified() const {
   return dyn_cast_or_null<llvm::UnsetInit>(def);
 }
 
-bool tblgen::DagLeaf::isOperandMatcher() const {
+bool DagLeaf::isOperandMatcher() const {
   // Operand matchers specify a type constraint.
   return isSubClassOf("TypeConstraint");
 }
 
-bool tblgen::DagLeaf::isAttrMatcher() const {
+bool DagLeaf::isAttrMatcher() const {
   // Attribute matchers specify an attribute constraint.
   return isSubClassOf("AttrConstraint");
 }
 
-bool tblgen::DagLeaf::isNativeCodeCall() const {
+bool DagLeaf::isNativeCodeCall() const {
   return isSubClassOf("NativeCodeCall");
 }
 
-bool tblgen::DagLeaf::isConstantAttr() const {
-  return isSubClassOf("ConstantAttr");
-}
+bool DagLeaf::isConstantAttr() const { return isSubClassOf("ConstantAttr"); }
 
-bool tblgen::DagLeaf::isEnumAttrCase() const {
+bool DagLeaf::isEnumAttrCase() const {
   return isSubClassOf("EnumAttrCaseInfo");
 }
 
-bool tblgen::DagLeaf::isStringAttr() const {
+bool DagLeaf::isStringAttr() const {
   return isa<llvm::StringInit, llvm::CodeInit>(def);
 }
 
-tblgen::Constraint tblgen::DagLeaf::getAsConstraint() const {
+Constraint DagLeaf::getAsConstraint() const {
   assert((isOperandMatcher() || isAttrMatcher()) &&
          "the DAG leaf must be operand or attribute");
   return Constraint(cast<llvm::DefInit>(def)->getDef());
 }
 
-tblgen::ConstantAttr tblgen::DagLeaf::getAsConstantAttr() const {
+ConstantAttr DagLeaf::getAsConstantAttr() const {
   assert(isConstantAttr() && "the DAG leaf must be constant attribute");
   return ConstantAttr(cast<llvm::DefInit>(def));
 }
 
-tblgen::EnumAttrCase tblgen::DagLeaf::getAsEnumAttrCase() const {
+EnumAttrCase DagLeaf::getAsEnumAttrCase() const {
   assert(isEnumAttrCase() && "the DAG leaf must be an enum attribute case");
   return EnumAttrCase(cast<llvm::DefInit>(def));
 }
 
-std::string tblgen::DagLeaf::getConditionTemplate() const {
+std::string DagLeaf::getConditionTemplate() const {
   return getAsConstraint().getConditionTemplate();
 }
 
-llvm::StringRef tblgen::DagLeaf::getNativeCodeTemplate() const {
+llvm::StringRef DagLeaf::getNativeCodeTemplate() const {
   assert(isNativeCodeCall() && "the DAG leaf must be NativeCodeCall");
   return cast<llvm::DefInit>(def)->getDef()->getValueAsString("expression");
 }
 
-std::string tblgen::DagLeaf::getStringAttr() const {
+std::string DagLeaf::getStringAttr() const {
   assert(isStringAttr() && "the DAG leaf must be string attribute");
   return def->getAsUnquotedString();
 }
-bool tblgen::DagLeaf::isSubClassOf(StringRef superclass) const {
+bool DagLeaf::isSubClassOf(StringRef superclass) const {
   if (auto *defInit = dyn_cast_or_null<llvm::DefInit>(def))
     return defInit->getDef()->isSubClassOf(superclass);
   return false;
 }
 
-void tblgen::DagLeaf::print(raw_ostream &os) const {
+void DagLeaf::print(raw_ostream &os) const {
   if (def)
     def->print(os);
 }
 
 //===----------------------------------------------------------------------===//
 // DagNode
 //===----------------------------------------------------------------------===//
 
-bool tblgen::DagNode::isNativeCodeCall() const {
+bool DagNode::isNativeCodeCall() const {
   if (auto *defInit = dyn_cast_or_null<llvm::DefInit>(node->getOperator()))
     return defInit->getDef()->isSubClassOf("NativeCodeCall");
   return false;
 }
 
-bool tblgen::DagNode::isOperation() const {
+bool DagNode::isOperation() const {
   return !isNativeCodeCall() && !isReplaceWithValue() && !isLocationDirective();
 }
 
-llvm::StringRef tblgen::DagNode::getNativeCodeTemplate() const {
+llvm::StringRef DagNode::getNativeCodeTemplate() const {
   assert(isNativeCodeCall() && "the DAG leaf must be NativeCodeCall");
   return cast<llvm::DefInit>(node->getOperator())
       ->getDef()
       ->getValueAsString("expression");
 }
 
-llvm::StringRef tblgen::DagNode::getSymbol() const {
-  return node->getNameStr();
-}
+llvm::StringRef DagNode::getSymbol() const { return node->getNameStr(); }
 
-Operator &tblgen::DagNode::getDialectOp(RecordOperatorMap *mapper) const {
+Operator &DagNode::getDialectOp(RecordOperatorMap *mapper) const {
   llvm::Record *opDef = cast<llvm::DefInit>(node->getOperator())->getDef();
   auto it = mapper->find(opDef);
   if (it != mapper->end())
     return *it->second;
   return *mapper->try_emplace(opDef, std::make_unique<Operator>(opDef))
               .first->second;
 }
 
-int tblgen::DagNode::getNumOps() const {
+int DagNode::getNumOps() const {
   int count = isReplaceWithValue() ? 0 : 1;
   for (int i = 0, e = getNumArgs(); i != e; ++i) {
     if (auto child = getArgAsNestedDag(i))
       count += child.getNumOps();
   }
   return count;
 }
 
-int tblgen::DagNode::getNumArgs() const { return node->getNumArgs(); }
+int DagNode::getNumArgs() const { return node->getNumArgs(); }
 
-bool tblgen::DagNode::isNestedDagArg(unsigned index) const {
+bool DagNode::isNestedDagArg(unsigned index) const {
   return isa<llvm::DagInit>(node->getArg(index));
 }
 
-tblgen::DagNode tblgen::DagNode::getArgAsNestedDag(unsigned index) const {
+DagNode DagNode::getArgAsNestedDag(unsigned index) const {
   return DagNode(dyn_cast_or_null<llvm::DagInit>(node->getArg(index)));
 }
 
-tblgen::DagLeaf tblgen::DagNode::getArgAsLeaf(unsigned index) const {
+DagLeaf DagNode::getArgAsLeaf(unsigned index) const {
   assert(!isNestedDagArg(index));
   return DagLeaf(node->getArg(index));
 }
 
-StringRef tblgen::DagNode::getArgName(unsigned index) const {
+StringRef DagNode::getArgName(unsigned index) const {
   return node->getArgNameStr(index);
 }
 
-bool tblgen::DagNode::isReplaceWithValue() const {
+bool DagNode::isReplaceWithValue() const {
   auto *dagOpDef = cast<llvm::DefInit>(node->getOperator())->getDef();
   return dagOpDef->getName() == "replaceWithValue";
 }
 
-bool tblgen::DagNode::isLocationDirective() const {
+bool DagNode::isLocationDirective() const {
   auto *dagOpDef = cast<llvm::DefInit>(node->getOperator())->getDef();
   return dagOpDef->getName() == "location";
 }
 
-void tblgen::DagNode::print(raw_ostream &os) const {
+void DagNode::print(raw_ostream &os) const {
   if (node)
     node->print(os);
 }
 
 //===----------------------------------------------------------------------===//
 // SymbolInfoMap
 //===----------------------------------------------------------------------===//
 
-StringRef tblgen::SymbolInfoMap::getValuePackName(StringRef symbol,
-                                                  int *index) {
+StringRef SymbolInfoMap::getValuePackName(StringRef symbol, int *index) {
   StringRef name, indexStr;
   int idx = -1;
   std::tie(name, indexStr) = symbol.rsplit("__");
 
   if (indexStr.consumeInteger(10, idx)) {
     // The second part is not an index; we return the whole symbol as-is.
     return symbol;
   }
   if (index) {
     *index = idx;
   }
   return name;
 }
 
-tblgen::SymbolInfoMap::SymbolInfo::SymbolInfo(const Operator *op,
-                                              SymbolInfo::Kind kind,
-                                              Optional<int> index)
+SymbolInfoMap::SymbolInfo::SymbolInfo(const Operator *op, SymbolInfo::Kind kind,
     : op(op), kind(kind), argIndex(index) {}
 
-int tblgen::SymbolInfoMap::SymbolInfo::getStaticValueCount() const {
+int SymbolInfoMap::SymbolInfo::getStaticValueCount() const {
   switch (kind) {
   case Kind::Attr:
   case Kind::Operand:
   case Kind::Value:
     return 1;
   case Kind::Result:
     return op->getNumResults();
   }
   llvm_unreachable("unknown kind");
 }
 
-std::string
-tblgen::SymbolInfoMap::SymbolInfo::getVarDecl(StringRef name) const {
+std::string SymbolInfoMap::SymbolInfo::getVarDecl(StringRef name) const {
   LLVM_DEBUG(llvm::dbgs() << "getVarDecl for '" << name << "': ");
   switch (kind) {
   case Kind::Attr: {
     auto type =
         op->getArg(*argIndex).get<NamedAttribute *>()->attr.getStorageType();
     return std::string(formatv("{0} {1};\n", type, name));
   }
   case Kind::Operand: {
     // Use operand range for captured operands (to support potential variadic
     // operands).
     return std::string(
         formatv("Operation::operand_range {0}(op0->getOperands());\n", name));
   }
   case Kind::Value: {
     return std::string(formatv("ArrayRef<Value> {0};\n", name));
   }
   case Kind::Result: {
     // Use the op itself for captured results.
     return std::string(formatv("{0} {1};\n", op->getQualCppClassName(), name));
   }
   }
   llvm_unreachable("unknown kind");
 }
 
-std::string tblgen::SymbolInfoMap::SymbolInfo::getValueAndRangeUse(
+std::string SymbolInfoMap::SymbolInfo::getValueAndRangeUse(
     StringRef name, int index, const char *fmt, const char *separator) const {
   LLVM_DEBUG(llvm::dbgs() << "getValueAndRangeUse for '" << name << "': ");
   switch (kind) {
   case Kind::Attr: {
     assert(index < 0);
     auto repl = formatv(fmt, name);
     LLVM_DEBUG(llvm::dbgs() << repl << " (Attr)\n");
     return std::string(repl);
case Kind::Value: {
     auto repl = formatv(fmt, name);
     LLVM_DEBUG(llvm::dbgs() << repl << " (Value)\n");
     return std::string(repl);
   }
   }
   llvm_unreachable("unknown kind");
 }
 
-std::string tblgen::SymbolInfoMap::SymbolInfo::getAllRangeUse(
+std::string SymbolInfoMap::SymbolInfo::getAllRangeUse(
     StringRef name, int index, const char *fmt, const char *separator) const {
   LLVM_DEBUG(llvm::dbgs() << "getAllRangeUse for '" << name << "': ");
   switch (kind) {
   case Kind::Attr:
   case Kind::Operand: {
     assert(index < 0 && "only allowed for symbol bound to result");
     auto repl = formatv(fmt, name);
     LLVM_DEBUG(llvm::dbgs() << repl << " (Operand/Attr)\n");
case Kind::Value: {
     auto repl = formatv(fmt, formatv("{{{0}}", name));
     LLVM_DEBUG(llvm::dbgs() << repl << " (Value)\n");
     return std::string(repl);
   }
   }
   llvm_unreachable("unknown kind");
 }
 
-bool tblgen::SymbolInfoMap::bindOpArgument(StringRef symbol, const Operator &op,
-                                           int argIndex) {
+bool SymbolInfoMap::bindOpArgument(StringRef symbol, const Operator &op,
   StringRef name = getValuePackName(symbol);
   if (name != symbol) {
     auto error = formatv(
         "symbol '{0}' with trailing index cannot bind to op argument", symbol);
     PrintFatalError(loc, error);
   }
 
   auto symInfo = op.getArg(argIndex).is<NamedAttribute *>()
                      ? SymbolInfo::getAttr(&op, argIndex)
                      : SymbolInfo::getOperand(&op, argIndex);
 
   return symbolInfoMap.insert({symbol, symInfo}).second;
 }
 
-bool tblgen::SymbolInfoMap::bindOpResult(StringRef symbol, const Operator &op) {
+bool SymbolInfoMap::bindOpResult(StringRef symbol, const Operator &op) {
   StringRef name = getValuePackName(symbol);
   return symbolInfoMap.insert({name, SymbolInfo::getResult(&op)}).second;
 }
 
-bool tblgen::SymbolInfoMap::bindValue(StringRef symbol) {
+bool SymbolInfoMap::bindValue(StringRef symbol) {
   return symbolInfoMap.insert({symbol, SymbolInfo::getValue()}).second;
 }
 
-bool tblgen::SymbolInfoMap::contains(StringRef symbol) const {
+bool SymbolInfoMap::contains(StringRef symbol) const {
   return find(symbol) != symbolInfoMap.end();
 }
 
-tblgen::SymbolInfoMap::const_iterator
-tblgen::SymbolInfoMap::find(StringRef key) const {
+SymbolInfoMap::const_iterator SymbolInfoMap::find(StringRef key) const {
   StringRef name = getValuePackName(key);
   return symbolInfoMap.find(name);
 }
 
-int tblgen::SymbolInfoMap::getStaticValueCount(StringRef symbol) const {
+int SymbolInfoMap::getStaticValueCount(StringRef symbol) const {
   StringRef name = getValuePackName(symbol);
   if (name != symbol) {
     // If there is a trailing index inside symbol, it references just one
     // static value.
     return 1;
   }
   // Otherwise, find how many it represents by querying the symbol's info.
   return find(name)->getValue().getStaticValueCount();
 }
 
-std::string
-tblgen::SymbolInfoMap::getValueAndRangeUse(StringRef symbol, const char *fmt,
+std::string SymbolInfoMap::getValueAndRangeUse(StringRef symbol,
+                                               const char *fmt,
                                                const char *separator) const {
   int index = -1;
   StringRef name = getValuePackName(symbol, &index);
 
   auto it = symbolInfoMap.find(name);
   if (it == symbolInfoMap.end()) {
     auto error = formatv("referencing unbound symbol '{0}'", symbol);
     PrintFatalError(loc, error);
   }
 
   return it->getValue().getValueAndRangeUse(name, index, fmt, separator);
 }
 
-std::string tblgen::SymbolInfoMap::getAllRangeUse(StringRef symbol,
-                                                  const char *fmt,
-                                                  const char *separator) const {
+std::string SymbolInfoMap::getAllRangeUse(StringRef symbol, const char *fmt,
   int index = -1;
   StringRef name = getValuePackName(symbol, &index);
 
   auto it = symbolInfoMap.find(name);
   if (it == symbolInfoMap.end()) {
     auto error = formatv("referencing unbound symbol '{0}'", symbol);
     PrintFatalError(loc, error);
   }
 
   return it->getValue().getAllRangeUse(name, index, fmt, separator);
 }
 
 //===----------------------------------------------------------------------===//
 // Pattern
 //==----------------------------------------------------------------------===//
 
-tblgen::Pattern::Pattern(const llvm::Record *def, RecordOperatorMap *mapper)
+Pattern::Pattern(const llvm::Record *def, RecordOperatorMap *mapper)
     : def(*def), recordOpMap(mapper) {}
 
-tblgen::DagNode tblgen::Pattern::getSourcePattern() const {
-  return tblgen::DagNode(def.getValueAsDag("sourcePattern"));
+DagNode Pattern::getSourcePattern() const {
+  return DagNode(def.getValueAsDag("sourcePattern"));
 }
 
-int tblgen::Pattern::getNumResultPatterns() const {
+int Pattern::getNumResultPatterns() const {
   auto *results = def.getValueAsListInit("resultPatterns");
   return results->size();
 }
 
-tblgen::DagNode tblgen::Pattern::getResultPattern(unsigned index) const {
+DagNode Pattern::getResultPattern(unsigned index) const {
   auto *results = def.getValueAsListInit("resultPatterns");
-  return tblgen::DagNode(cast<llvm::DagInit>(results->getElement(index)));
+  return DagNode(cast<llvm::DagInit>(results->getElement(index)));
 }
 
-void tblgen::Pattern::collectSourcePatternBoundSymbols(
-    tblgen::SymbolInfoMap &infoMap) {
+void Pattern::collectSourcePatternBoundSymbols(SymbolInfoMap &infoMap) {
   LLVM_DEBUG(llvm::dbgs() << "start collecting source pattern bound symbols\n");
   collectBoundSymbols(getSourcePattern(), infoMap, /*isSrcPattern=*/true);
   LLVM_DEBUG(llvm::dbgs() << "done collecting source pattern bound symbols\n");
 }
 
-void tblgen::Pattern::collectResultPatternBoundSymbols(
-    tblgen::SymbolInfoMap &infoMap) {
+void Pattern::collectResultPatternBoundSymbols(SymbolInfoMap &infoMap) {
   LLVM_DEBUG(llvm::dbgs() << "start collecting result pattern bound symbols\n");
   for (int i = 0, e = getNumResultPatterns(); i < e; ++i) {
     auto pattern = getResultPattern(i);
     collectBoundSymbols(pattern, infoMap, /*isSrcPattern=*/false);
   }
   LLVM_DEBUG(llvm::dbgs() << "done collecting result pattern bound symbols\n");
 }
 
-const tblgen::Operator &tblgen::Pattern::getSourceRootOp() {
+const Operator &Pattern::getSourceRootOp() {
   return getSourcePattern().getDialectOp(recordOpMap);
 }
 
-tblgen::Operator &tblgen::Pattern::getDialectOp(DagNode node) {
+Operator &Pattern::getDialectOp(DagNode node) {
   return node.getDialectOp(recordOpMap);
 }
 
-std::vector<tblgen::AppliedConstraint> tblgen::Pattern::getConstraints() const {
+std::vector<AppliedConstraint> Pattern::getConstraints() const {
   auto *listInit = def.getValueAsListInit("constraints");
-  std::vector<tblgen::AppliedConstraint> ret;
+  std::vector<AppliedConstraint> ret;
   ret.reserve(listInit->size());
 
   for (auto it : *listInit) {
     auto *dagInit = dyn_cast<llvm::DagInit>(it);
     if (!dagInit)
       PrintFatalError(def.getLoc(), "all elements in Pattern multi-entity "
                                     "constraints should be DAG nodes");
 
for (auto it : *listInit) {
     }
 
     ret.emplace_back(cast<llvm::DefInit>(dagInit->getOperator())->getDef(),
                      dagInit->getNameStr(), std::move(entities));
   }
   return ret;
 }
 
-int tblgen::Pattern::getBenefit() const {
+int Pattern::getBenefit() const {
   // The initial benefit value is a heuristic with number of ops in the source
   // pattern.
   int initBenefit = getSourcePattern().getNumOps();
   llvm::DagInit *delta = def.getValueAsDag("benefitDelta");
   if (delta->getNumArgs() != 1 || !isa<llvm::IntInit>(delta->getArg(0))) {
     PrintFatalError(def.getLoc(),
                     "The 'addBenefit' takes and only takes one integer value");
   }
   return initBenefit + dyn_cast<llvm::IntInit>(delta->getArg(0))->getValue();
 }
 
-std::vector<tblgen::Pattern::IdentifierLine>
-tblgen::Pattern::getLocation() const {
+std::vector<Pattern::IdentifierLine> Pattern::getLocation() const {
   std::vector<std::pair<StringRef, unsigned>> result;
   result.reserve(def.getLoc().size());
   for (auto loc : def.getLoc()) {
     unsigned buf = llvm::SrcMgr.FindBufferContainingLoc(loc);
     assert(buf && "invalid source location");
     result.emplace_back(
         llvm::SrcMgr.getBufferInfo(buf).Buffer->getBufferIdentifier(),
         llvm::SrcMgr.getLineAndColumn(loc, buf).first);
   }
   return result;
 }
 
-void tblgen::Pattern::collectBoundSymbols(DagNode tree, SymbolInfoMap &infoMap,
-                                          bool isSrcPattern) {
+void Pattern::collectBoundSymbols(DagNode tree, SymbolInfoMap &infoMap,
   auto treeName = tree.getSymbol();
   if (!tree.isOperation()) {
     if (!treeName.empty()) {
       PrintFatalError(
           def.getLoc(),
           formatv("binding symbol '{0}' to non-operation unsupported right now",
                   treeName));
     }

mlir/lib/TableGen/Predicate.cpp

 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 
 using namespace mlir;
+using namespace tblgen;
 
 // Construct a Predicate from a record.
-tblgen::Pred::Pred(const llvm::Record *record) : def(record) {
+Pred::Pred(const llvm::Record *record) : def(record) {
   assert(def->isSubClassOf("Pred") &&
          "must be a subclass of TableGen 'Pred' class");
 }
 
 // Construct a Predicate from an initializer.
-tblgen::Pred::Pred(const llvm::Init *init) : def(nullptr) {
+Pred::Pred(const llvm::Init *init) : def(nullptr) {
   if (const auto *defInit = dyn_cast_or_null<llvm::DefInit>(init))
     def = defInit->getDef();
 }
 
-std::string tblgen::Pred::getCondition() const {
+std::string Pred::getCondition() const {
   // Static dispatch to subclasses.
   if (def->isSubClassOf("CombinedPred"))
     return static_cast<const CombinedPred *>(this)->getConditionImpl();
   if (def->isSubClassOf("CPred"))
     return static_cast<const CPred *>(this)->getConditionImpl();
   llvm_unreachable("Pred::getCondition must be overridden in subclasses");
 }
 
-bool tblgen::Pred::isCombined() const {
+bool Pred::isCombined() const {
   return def && def->isSubClassOf("CombinedPred");
 }
 
-ArrayRef<llvm::SMLoc> tblgen::Pred::getLoc() const { return def->getLoc(); }
+ArrayRef<llvm::SMLoc> Pred::getLoc() const { return def->getLoc(); }
 
-tblgen::CPred::CPred(const llvm::Record *record) : Pred(record) {
+CPred::CPred(const llvm::Record *record) : Pred(record) {
   assert(def->isSubClassOf("CPred") &&
          "must be a subclass of Tablegen 'CPred' class");
 }
 
-tblgen::CPred::CPred(const llvm::Init *init) : Pred(init) {
+CPred::CPred(const llvm::Init *init) : Pred(init) {
   assert((!def || def->isSubClassOf("CPred")) &&
          "must be a subclass of Tablegen 'CPred' class");
 }
 
 // Get condition of the C Predicate.
-std::string tblgen::CPred::getConditionImpl() const {
+std::string CPred::getConditionImpl() const {
   assert(!isNull() && "null predicate does not have a condition");
   return std::string(def->getValueAsString("predExpr"));
 }
 
-tblgen::CombinedPred::CombinedPred(const llvm::Record *record) : Pred(record) {
+CombinedPred::CombinedPred(const llvm::Record *record) : Pred(record) {
   assert(def->isSubClassOf("CombinedPred") &&
          "must be a subclass of Tablegen 'CombinedPred' class");
 }
 
-tblgen::CombinedPred::CombinedPred(const llvm::Init *init) : Pred(init) {
+CombinedPred::CombinedPred(const llvm::Init *init) : Pred(init) {
   assert((!def || def->isSubClassOf("CombinedPred")) &&
          "must be a subclass of Tablegen 'CombinedPred' class");
 }
 
-const llvm::Record *tblgen::CombinedPred::getCombinerDef() const {
+const llvm::Record *CombinedPred::getCombinerDef() const {
   assert(def->getValue("kind") && "CombinedPred must have a value 'kind'");
   return def->getValueAsDef("kind");
 }
 
-const std::vector<llvm::Record *> tblgen::CombinedPred::getChildren() const {
+const std::vector<llvm::Record *> CombinedPred::getChildren() const {
   assert(def->getValue("children") &&
          "CombinedPred must have a value 'children'");
   return def->getValueAsListOfDefs("children");
 }
 
 namespace {
 // Kinds of nodes in a logical predicate tree.
 enum class PredCombinerKind {
   Leaf,
   And,
   Or,
   Not,
   SubstLeaves,
   Concat,
   // Special kinds that are used in simplification.
   False,
   True
 };
 
 // A node in a logical predicate tree.
 struct PredNode {
   PredCombinerKind kind;
-  const tblgen::Pred *predicate;
+  const Pred *predicate;
   SmallVector<PredNode *, 4> children;
   std::string expr;
 
   // Prefix and suffix are used by ConcatPred.
   std::string prefix;
   std::string suffix;
 };
 } // end anonymous namespace
 
 // Get a predicate tree node kind based on the kind used in the predicate
 // TableGen record.
-static PredCombinerKind getPredCombinerKind(const tblgen::Pred &pred) {
+static PredCombinerKind getPredCombinerKind(const Pred &pred) {
   if (!pred.isCombined())
     return PredCombinerKind::Leaf;
 
-  const auto &combinedPred = static_cast<const tblgen::CombinedPred &>(pred);
+  const auto &combinedPred = static_cast<const CombinedPred &>(pred);
   return llvm::StringSwitch<PredCombinerKind>(
              combinedPred.getCombinerDef()->getName())
       .Case("PredCombinerAnd", PredCombinerKind::And)
       .Case("PredCombinerOr", PredCombinerKind::Or)
       .Case("PredCombinerNot", PredCombinerKind::Not)
       .Case("PredCombinerSubstLeaves", PredCombinerKind::SubstLeaves)
       .Case("PredCombinerConcat", PredCombinerKind::Concat);
 }
 
 namespace {
 // Substitution<pattern, replacement>.
 using Subst = std::pair<StringRef, StringRef>;
 } // end anonymous namespace
 
 // Build the predicate tree starting from the top-level predicate, which may
 // have children, and perform leaf substitutions inplace.  Note that after
 // substitution, nodes are still pointing to the original TableGen record.
 // All nodes are created within "allocator".
 static PredNode *
-buildPredicateTree(const tblgen::Pred &root,
+buildPredicateTree(const Pred &root,
                    llvm::SpecificBumpPtrAllocator<PredNode> &allocator,
                    ArrayRef<Subst> substitutions) {
   auto *rootNode = allocator.Allocate();
   new (rootNode) PredNode;
   rootNode->kind = getPredCombinerKind(root);
   rootNode->predicate = &root;
   if (!root.isCombined()) {
     rootNode->expr = root.getCondition();
if (!root.isCombined()) {
     }
     return rootNode;
   }
 
   // If the current combined predicate is a leaf substitution, append it to the
   // list before continuing.
   auto allSubstitutions = llvm::to_vector<4>(substitutions);
   if (rootNode->kind == PredCombinerKind::SubstLeaves) {
-    const auto &substPred = static_cast<const tblgen::SubstLeavesPred &>(root);
+    const auto &substPred = static_cast<const SubstLeavesPred &>(root);
     allSubstitutions.push_back(
         {substPred.getPattern(), substPred.getReplacement()});
   }
   // If the current predicate is a ConcatPred, record the prefix and suffix.
   else if (rootNode->kind == PredCombinerKind::Concat) {
-    const auto &concatPred = static_cast<const tblgen::ConcatPred &>(root);
+    const auto &concatPred = static_cast<const ConcatPred &>(root);
     rootNode->prefix = std::string(concatPred.getPrefix());
     rootNode->suffix = std::string(concatPred.getSuffix());
   }
 
   // Build child subtrees.
-  auto combined = static_cast<const tblgen::CombinedPred &>(root);
+  auto combined = static_cast<const CombinedPred &>(root);
   for (const auto *record : combined.getChildren()) {
     auto childTree =
-        buildPredicateTree(tblgen::Pred(record), allocator, allSubstitutions);
+        buildPredicateTree(Pred(record), allocator, allSubstitutions);
     rootNode->children.push_back(childTree);
   }
   return rootNode;
 }
 
 // Simplify a predicate tree rooted at "node" using the predicates that are
 // known to be true(false).  For AND(OR) combined predicates, if any of the
 // children is known to be false(true), the result is also false(true).
 // Furthermore, for AND(OR) combined predicates, children that are known to be
 // true(false) don't have to be checked dynamically.
-static PredNode *propagateGroundTruth(
-    PredNode *node, const llvm::SmallPtrSetImpl<tblgen::Pred *> &knownTruePreds,
-    const llvm::SmallPtrSetImpl<tblgen::Pred *> &knownFalsePreds) {
+static PredNode *
+propagateGroundTruth(PredNode *node,
+                     const llvm::SmallPtrSetImpl<Pred *> &knownTruePreds,
+                     const llvm::SmallPtrSetImpl<Pred *> &knownFalsePreds) {
   // If the current predicate is known to be true or false, change the kind of
   // the node and return immediately.
   if (knownTruePreds.count(node->predicate) != 0) {
     node->kind = PredCombinerKind::True;
     node->children.clear();
     return node;
   }
   if (knownFalsePreds.count(node->predicate) != 0) {
if (root.kind == PredCombinerKind::SubstLeaves) {
     assert(childExpressions.size() == 1 &&
            "substitution predicate must have one child");
     return childExpressions[0];
   }
 
   llvm::PrintFatalError(root.predicate->getLoc(), "unsupported predicate kind");
 }
 
-std::string tblgen::CombinedPred::getConditionImpl() const {
+std::string CombinedPred::getConditionImpl() const {
   llvm::SpecificBumpPtrAllocator<PredNode> allocator;
   auto predicateTree = buildPredicateTree(*this, allocator, {});
-  predicateTree = propagateGroundTruth(
-      predicateTree,
-      /*knownTruePreds=*/llvm::SmallPtrSet<tblgen::Pred *, 2>(),
-      /*knownFalsePreds=*/llvm::SmallPtrSet<tblgen::Pred *, 2>());
+  predicateTree =
+      propagateGroundTruth(predicateTree,
+                           /*knownTruePreds=*/llvm::SmallPtrSet<Pred *, 2>(),
+                           /*knownFalsePreds=*/llvm::SmallPtrSet<Pred *, 2>());
 
   return getCombinedCondition(*predicateTree);
 }
 
-StringRef tblgen::SubstLeavesPred::getPattern() const {
+StringRef SubstLeavesPred::getPattern() const {
   return def->getValueAsString("pattern");
 }
 
-StringRef tblgen::SubstLeavesPred::getReplacement() const {
+StringRef SubstLeavesPred::getReplacement() const {
   return def->getValueAsString("replacement");
 }
 
-StringRef tblgen::ConcatPred::getPrefix() const {
+StringRef ConcatPred::getPrefix() const {
   return def->getValueAsString("prefix");
 }
 
-StringRef tblgen::ConcatPred::getSuffix() const {
+StringRef ConcatPred::getSuffix() const {
   return def->getValueAsString("suffix");
 }