[mlir] Simplify various pieces of code now that Identifier has access to the Context/Dialect

[rriddle]

Summary

This also exposed a bug in Dialect loading where it was not correctly identifying identifiers that had the dialect namespace as a prefix.

[nathanchance]

This patch introduces a build error according to my bisect:

$ git bisect log
# bad: [bf4dbc49843ca24e90e37f127ceef988286cd1c6] [flang][f18] Add missing line in help text (nfc)
# good: [c218c80c730a14a1cbcebd588b18220a879702c6] [libcxx] [test] Quote the path to the python interpreter
git bisect start 'bf4dbc49843ca24e90e37f127ceef988286cd1c6' 'c218c80c730a14a1cbcebd588b18220a879702c6'
# bad: [302cc8421ee4ac1cf910dd6cd3306c6eae8d0d3e] [clang-tidy] Simplify boolean expr check
git bisect bad 302cc8421ee4ac1cf910dd6cd3306c6eae8d0d3e
# good: [c90dac27e94ec354a3e8919556ac5bc89b62c731] [clang] Print 32 candidates on the first failure, with -fshow-overloads=best.
git bisect good c90dac27e94ec354a3e8919556ac5bc89b62c731
# good: [e4dd614ae81194b0a50361a91f8bd4364916ef2e] [libcxx] cleans up __cpp_concepts mess
git bisect good e4dd614ae81194b0a50361a91f8bd4364916ef2e
# good: [5077d42cfa427598826eb7b69ad805bad8f4ec9d] [flang][fir][NFC] Removes deprecated messages in builds.
git bisect good 5077d42cfa427598826eb7b69ad805bad8f4ec9d
# good: [9e0d55024d4ed776f209ee04e260bdd314854993] [clang][NFC] Clean up whitespace in ClangOpcodesEmitter output
git bisect good 9e0d55024d4ed776f209ee04e260bdd314854993
# bad: [df6fb4d392e530fbf9d4e331711c500d47980dcc] [llvm] Add assertions for the smart pointers with the possibility to be null in DWARFLinker::loadClangModule
git bisect bad df6fb4d392e530fbf9d4e331711c500d47980dcc
# bad: [2e2ee4300d1f9766209d435c0d8c44c72092b974] [test] Add -triple x86_64 to attr-retain.cpp
git bisect bad 2e2ee4300d1f9766209d435c0d8c44c72092b974
# bad: [e6260ad043d84c54d10e463dd82de829c1be24f7] [mlir] Simplify various pieces of code now that Identifier has access to the Context/Dialect
git bisect bad e6260ad043d84c54d10e463dd82de829c1be24f7
# good: [16abacaea9db653b41808fc37277b68168438059] [MLIR][TOSA] Resubmit Tosa to Standard/SCF Lowerings (const, if, while)"
git bisect good 16abacaea9db653b41808fc37277b68168438059
# first bad commit: [e6260ad043d84c54d10e463dd82de829c1be24f7] [mlir] Simplify various pieces of code now that Identifier has access to the Context/Dialect

$ mkdir -p build

$ cd build

$ cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -DLLVM_ENABLE_PROJECTS=all ../llvm

$ ninja projects/debuginfo-tests/CMakeFiles/check-gdb-mlir-support.dir/llvm-prettyprinters/gdb/mlir-support.cpp.o
/home/nathan/src/llvm-project/debuginfo-tests/llvm-prettyprinters/gdb/mlir-support.cpp:29:55: error: no matching function for call to ‘mlir::NameLoc::get(mlir::Identifier&, mlir::MLIRContext*)’
   29 | auto NameLoc = mlir::NameLoc::get(Identifier, &Context);
      |                                                       ^
In file included from /home/nathan/src/llvm-project/debuginfo-tests/llvm-prettyprinters/gdb/mlir-support.cpp:4:
/home/nathan/src/llvm-project/llvm/../mlir/include/mlir/IR/Location.h:173:19: note: candidate: ‘static mlir::Location mlir::NameLoc::get(mlir::Identifier, mlir::Location)’
  173 |   static Location get(Identifier name, Location child);
      |                   ^~~
/home/nathan/src/llvm-project/llvm/../mlir/include/mlir/IR/Location.h:173:49: note:   no known conversion for argument 2 from ‘mlir::MLIRContext*’ to ‘mlir::Location’
  173 |   static Location get(Identifier name, Location child);
      |                                        ~~~~~~~~~^~~~~
/home/nathan/src/llvm-project/llvm/../mlir/include/mlir/IR/Location.h:176:19: note: candidate: ‘static mlir::Location mlir::NameLoc::get(mlir::Identifier)’
  176 |   static Location get(Identifier name);
      |                   ^~~
/home/nathan/src/llvm-project/llvm/../mlir/include/mlir/IR/Location.h:176:19: note:   candidate expects 1 argument, 2 provided
/home/nathan/src/llvm-project/debuginfo-tests/llvm-prettyprinters/gdb/mlir-support.cpp:31:72: error: no matching function for call to ‘mlir::FusedLoc::get(<brace-enclosed initializer list>, mlir::MLIRContext*)’
   31 | auto FusedLoc = mlir::FusedLoc::get({FileLineColLoc, NameLoc}, &Context);
      |                                                                        ^
In file included from /home/nathan/src/llvm-project/debuginfo-tests/llvm-prettyprinters/gdb/mlir-support.cpp:4:
/home/nathan/src/llvm-project/llvm/../mlir/include/mlir/IR/Location.h:152:19: note: candidate: ‘static mlir::Location mlir::FusedLoc::get(llvm::ArrayRef<mlir::Location>, mlir::Attribute, mlir::MLIRContext*)’
  152 |   static Location get(ArrayRef<Location> locs, Attribute metadata,
      |                   ^~~
/home/nathan/src/llvm-project/llvm/../mlir/include/mlir/IR/Location.h:152:19: note:   candidate expects 3 arguments, 2 provided
/home/nathan/src/llvm-project/llvm/../mlir/include/mlir/IR/Location.h:154:19: note: candidate: ‘static mlir::Location mlir::FusedLoc::get(llvm::ArrayRef<mlir::Location>, mlir::MLIRContext*)’
  154 |   static Location get(ArrayRef<Location> locs, MLIRContext *context) {
      |                   ^~~
/home/nathan/src/llvm-project/llvm/../mlir/include/mlir/IR/Location.h:154:42: note:   no known conversion for argument 1 from ‘<brace-enclosed initializer list>’ to ‘llvm::ArrayRef<mlir::Location>’
  154 |   static Location get(ArrayRef<Location> locs, MLIRContext *context) {
      |                       ~~~~~~~~~~~~~~~~~~~^~~~
ninja: build stopped: subcommand failed.

Presumably the &Context should be removed but I am not sure, hence just the report.

[mehdi_amini]

Fixed in 068aa12f96af

mlir/examples/toy/Ch2/mlir/MLIRGen.cpp

private:
   /// The symbol table maps a variable name to a value in the current scope.
   /// Entering a function creates a new scope, and the function arguments are
   /// added to the mapping. When the processing of a function is terminated, the
   /// scope is destroyed and the mappings created in this scope are dropped.
   llvm::ScopedHashTable<StringRef, mlir::Value> symbolTable;
 
   /// Helper conversion for a Toy AST location to an MLIR location.
   mlir::Location loc(Location loc) {
-    return builder.getFileLineColLoc(builder.getIdentifier(*loc.file), loc.line,
+    return mlir::FileLineColLoc::get(builder.getIdentifier(*loc.file), loc.line,
                                      loc.col);
   }
 
   /// Declare a variable in the current scope, return success if the variable
   /// wasn't declared yet.
   mlir::LogicalResult declare(llvm::StringRef var, mlir::Value value) {
     if (symbolTable.count(var))
       return mlir::failure();

mlir/examples/toy/Ch3/mlir/MLIRGen.cpp

private:
   /// The symbol table maps a variable name to a value in the current scope.
   /// Entering a function creates a new scope, and the function arguments are
   /// added to the mapping. When the processing of a function is terminated, the
   /// scope is destroyed and the mappings created in this scope are dropped.
   llvm::ScopedHashTable<StringRef, mlir::Value> symbolTable;
 
   /// Helper conversion for a Toy AST location to an MLIR location.
   mlir::Location loc(Location loc) {
-    return builder.getFileLineColLoc(builder.getIdentifier(*loc.file), loc.line,
+    return mlir::FileLineColLoc::get(builder.getIdentifier(*loc.file), loc.line,
                                      loc.col);
   }
 
   /// Declare a variable in the current scope, return success if the variable
   /// wasn't declared yet.
   mlir::LogicalResult declare(llvm::StringRef var, mlir::Value value) {
     if (symbolTable.count(var))
       return mlir::failure();

mlir/examples/toy/Ch4/mlir/MLIRGen.cpp

private:
   /// The symbol table maps a variable name to a value in the current scope.
   /// Entering a function creates a new scope, and the function arguments are
   /// added to the mapping. When the processing of a function is terminated, the
   /// scope is destroyed and the mappings created in this scope are dropped.
   llvm::ScopedHashTable<StringRef, mlir::Value> symbolTable;
 
   /// Helper conversion for a Toy AST location to an MLIR location.
   mlir::Location loc(Location loc) {
-    return builder.getFileLineColLoc(builder.getIdentifier(*loc.file), loc.line,
+    return mlir::FileLineColLoc::get(builder.getIdentifier(*loc.file), loc.line,
                                      loc.col);
   }
 
   /// Declare a variable in the current scope, return success if the variable
   /// wasn't declared yet.
   mlir::LogicalResult declare(llvm::StringRef var, mlir::Value value) {
     if (symbolTable.count(var))
       return mlir::failure();

mlir/examples/toy/Ch5/mlir/MLIRGen.cpp

private:
   /// The symbol table maps a variable name to a value in the current scope.
   /// Entering a function creates a new scope, and the function arguments are
   /// added to the mapping. When the processing of a function is terminated, the
   /// scope is destroyed and the mappings created in this scope are dropped.
   llvm::ScopedHashTable<StringRef, mlir::Value> symbolTable;
 
   /// Helper conversion for a Toy AST location to an MLIR location.
   mlir::Location loc(Location loc) {
-    return builder.getFileLineColLoc(builder.getIdentifier(*loc.file), loc.line,
+    return mlir::FileLineColLoc::get(builder.getIdentifier(*loc.file), loc.line,
                                      loc.col);
   }
 
   /// Declare a variable in the current scope, return success if the variable
   /// wasn't declared yet.
   mlir::LogicalResult declare(llvm::StringRef var, mlir::Value value) {
     if (symbolTable.count(var))
       return mlir::failure();

mlir/examples/toy/Ch6/mlir/MLIRGen.cpp

private:
   /// The symbol table maps a variable name to a value in the current scope.
   /// Entering a function creates a new scope, and the function arguments are
   /// added to the mapping. When the processing of a function is terminated, the
   /// scope is destroyed and the mappings created in this scope are dropped.
   llvm::ScopedHashTable<StringRef, mlir::Value> symbolTable;
 
   /// Helper conversion for a Toy AST location to an MLIR location.
   mlir::Location loc(Location loc) {
-    return builder.getFileLineColLoc(builder.getIdentifier(*loc.file), loc.line,
+    return mlir::FileLineColLoc::get(builder.getIdentifier(*loc.file), loc.line,
                                      loc.col);
   }
 
   /// Declare a variable in the current scope, return success if the variable
   /// wasn't declared yet.
   mlir::LogicalResult declare(llvm::StringRef var, mlir::Value value) {
     if (symbolTable.count(var))
       return mlir::failure();

mlir/examples/toy/Ch7/mlir/MLIRGen.cpp

private:
   llvm::StringMap<mlir::FuncOp> functionMap;
 
   /// A mapping for named struct types to the underlying MLIR type and the
   /// original AST node.
   llvm::StringMap<std::pair<mlir::Type, StructAST *>> structMap;
 
   /// Helper conversion for a Toy AST location to an MLIR location.
   mlir::Location loc(Location loc) {
-    return builder.getFileLineColLoc(builder.getIdentifier(*loc.file), loc.line,
+    return mlir::FileLineColLoc::get(builder.getIdentifier(*loc.file), loc.line,
                                      loc.col);
   }
 
   /// Declare a variable in the current scope, return success if the variable
   /// wasn't declared yet.
   mlir::LogicalResult declare(VarDeclExprAST &var, mlir::Value value) {
     if (symbolTable.count(var.getName()))
       return mlir::failure();

mlir/include/mlir/IR/Builders.h

public:
   explicit Builder(Operation *op) : Builder(op->getContext()) {}
 
   MLIRContext *getContext() const { return context; }
 
   Identifier getIdentifier(StringRef str);
 
   // Locations.
   Location getUnknownLoc();
-  Location getFileLineColLoc(Identifier filename, unsigned line,
-                             unsigned column);
   Location getFusedLoc(ArrayRef<Location> locs,
                        Attribute metadata = Attribute());
 
   // Types.
   FloatType getBF16Type();
   FloatType getF16Type();
   FloatType getF32Type();
   FloatType getF64Type();

mlir/include/mlir/IR/BuiltinAttributes.h

 /// tested for attribute equality.
 class OpaqueAttr : public Attribute::AttrBase<OpaqueAttr, Attribute,
                                               detail::OpaqueAttributeStorage> {
 public:
   using Base::Base;
   using Base::getChecked;
 
   /// Get or create a new OpaqueAttr with the provided dialect and string data.
-  static OpaqueAttr get(MLIRContext *context, Identifier dialect,
-                        StringRef attrData, Type type);
+  static OpaqueAttr get(Identifier dialect, StringRef attrData, Type type);
 
   /// Get or create a new OpaqueAttr with the provided dialect and string data.
   /// If the given identifier is not a valid namespace for a dialect, then a
   /// null attribute is returned.
   static OpaqueAttr getChecked(function_ref<InFlightDiagnostic()> emitError,
                                Identifier dialect, StringRef attrData,
                                Type type);
 

mlir/include/mlir/IR/BuiltinTypes.td

let description = [{
     opaque<"llvm", "struct<(i32, float)>">
     opaque<"pdl", "value">
     ```
   }];
   let parameters = (ins
     "Identifier":$dialectNamespace,
     StringRefParameter<"">:$typeData
   );
+
+  let builders = [
+    TypeBuilderWithInferredContext<(ins
+      "Identifier":$dialectNamespace, CArg<"StringRef", "{}">:$typeData
+    ), [{
+      return $_get(dialectNamespace.getContext(), dialectNamespace, typeData);
+    }]>
+  ];
+  let skipDefaultBuilders = 1;
   let genVerifyDecl = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // TupleType
 //===----------------------------------------------------------------------===//
 
 def Builtin_Tuple : Builtin_Type<"Tuple"> {

mlir/include/mlir/IR/Location.h

 /// information.
 class FileLineColLoc
     : public Attribute::AttrBase<FileLineColLoc, LocationAttr,
                                  detail::FileLineColLocationStorage> {
 public:
   using Base::Base;
 
   /// Return a uniqued FileLineCol location object.
-  static Location get(Identifier filename, unsigned line, unsigned column,
-                      MLIRContext *context);
+  static Location get(Identifier filename, unsigned line, unsigned column);
   static Location get(StringRef filename, unsigned line, unsigned column,
                       MLIRContext *context);
 
   StringRef getFilename() const;
 
   unsigned getLine() const;
   unsigned getColumn() const;
 };

 public:
   using Base::Base;
 
   /// Return a uniqued name location object. The child location must not be
   /// another NameLoc.
   static Location get(Identifier name, Location child);
 
   /// Return a uniqued name location object with an unknown child.
-  static Location get(Identifier name, MLIRContext *context);
+  static Location get(Identifier name);
 
   /// Return the name identifier.
   Identifier getName() const;
 
   /// Return the child location.
   Location getChildLoc() const;
 };
 

mlir/include/mlir/IR/OpBase.td

 }
 
 def AnyComplex : Type<CPred<"$_self.isa<::mlir::ComplexType>()">,
                       "complex-type", "::mlir::ComplexType">;
 
 class OpaqueType<string dialect, string name, string summary>
   : Type<CPred<"isOpaqueTypeWithName($_self, \""#dialect#"\", \""#name#"\")">,
          summary, "::mlir::OpaqueType">,
-    BuildableType<"::mlir::OpaqueType::get($_builder.getContext(), "
+    BuildableType<"::mlir::OpaqueType::get("
                   "$_builder.getIdentifier(\"" # dialect # "\"), \""
                   # name # "\")">;
 
 // Function Type
 
 // Any function type.
 def FunctionType : Type<CPred<"$_self.isa<::mlir::FunctionType>()">,
                               "function type", "::mlir::FunctionType">;

mlir/include/mlir/IR/OperationSupport.h

 public:
   using RepresentationUnion =
       PointerUnion<Identifier, const AbstractOperation *>;
 
   OperationName(AbstractOperation *op) : representation(op) {}
   OperationName(StringRef name, MLIRContext *context);
 
   /// Return the name of the dialect this operation is registered to.
-  StringRef getDialect() const;
+  StringRef getDialectNamespace() const;
+
+  /// Return the Dialect this operation is registered to if it is loaded in the
+  /// context, or nullptr if the dialect isn't loaded.
+  Dialect *getDialect() const {
+    if (const auto *abstractOp = getAbstractOperation())
+      return &abstractOp->dialect;
+    return representation.get<Identifier>().getDialect();
+  }
 
   /// Return the operation name with dialect name stripped, if it has one.
   StringRef stripDialect() const;
 
   /// Return the name of this operation. This always succeeds.
   StringRef getStringRef() const;
 
   /// Return the name of this operation as an identifier. This always succeeds.

mlir/lib/CAPI/IR/BuiltinAttributes.cpp

 
 bool mlirAttributeIsAOpaque(MlirAttribute attr) {
   return unwrap(attr).isa<OpaqueAttr>();
 }
 
 MlirAttribute mlirOpaqueAttrGet(MlirContext ctx, MlirStringRef dialectNamespace,
                                 intptr_t dataLength, const char *data,
                                 MlirType type) {
-  return wrap(OpaqueAttr::get(
-      unwrap(ctx), Identifier::get(unwrap(dialectNamespace), unwrap(ctx)),
+  return wrap(
+      OpaqueAttr::get(Identifier::get(unwrap(dialectNamespace), unwrap(ctx)),
                       StringRef(data, dataLength), unwrap(type)));
 }
 
 MlirStringRef mlirOpaqueAttrGetDialectNamespace(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<OpaqueAttr>().getDialectNamespace().strref());
 }
 
 MlirStringRef mlirOpaqueAttrGetData(MlirAttribute attr) {
   return wrap(unwrap(attr).cast<OpaqueAttr>().getAttrData());

mlir/lib/IR/Builders.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // Locations.
 //===----------------------------------------------------------------------===//
 
 Location Builder::getUnknownLoc() { return UnknownLoc::get(context); }
 
-Location Builder::getFileLineColLoc(Identifier filename, unsigned line,
-                                    unsigned column) {
-  return FileLineColLoc::get(filename, line, column, context);
-}
-
 Location Builder::getFusedLoc(ArrayRef<Location> locs, Attribute metadata) {
   return FusedLoc::get(locs, metadata, context);
 }
 
 //===----------------------------------------------------------------------===//
 // Types.
 //===----------------------------------------------------------------------===//
 

mlir/lib/IR/BuiltinAttributes.cpp

 }
 
 IntegerSet IntegerSetAttr::getValue() const { return getImpl()->value; }
 
 //===----------------------------------------------------------------------===//
 // OpaqueAttr
 //===----------------------------------------------------------------------===//
 
-OpaqueAttr OpaqueAttr::get(MLIRContext *context, Identifier dialect,
-                           StringRef attrData, Type type) {
-  return Base::get(context, dialect, attrData, type);
+OpaqueAttr OpaqueAttr::get(Identifier dialect, StringRef attrData, Type type) {
+  return Base::get(dialect.getContext(), dialect, attrData, type);
 }
 
 OpaqueAttr OpaqueAttr::getChecked(function_ref<InFlightDiagnostic()> emitError,
                                   Identifier dialect, StringRef attrData,
                                   Type type) {
   return Base::getChecked(emitError, dialect.getContext(), dialect, attrData,
                           type);
 }

mlir/lib/IR/Dialect.cpp

parser.emitError(parser.getNameLoc())
       << "' provides no attribute parsing hook";
   return Attribute();
 }
 
 /// Parse a type registered to this dialect.
 Type Dialect::parseType(DialectAsmParser &parser) const {
   // If this dialect allows unknown types, then represent this with OpaqueType.
   if (allowsUnknownTypes()) {
-    auto ns = Identifier::get(getNamespace(), getContext());
-    return OpaqueType::get(getContext(), ns, parser.getFullSymbolSpec());
+    Identifier ns = Identifier::get(getNamespace(), getContext());
+    return OpaqueType::get(ns, parser.getFullSymbolSpec());
   }
 
   parser.emitError(parser.getNameLoc())
       << "dialect '" << getNamespace() << "' provides no type parsing hook";
   return Type();
 }
 
 /// Utility function that returns if the given string is a valid dialect

mlir/lib/IR/Location.cpp

 
 Location CallSiteLoc::getCaller() const { return getImpl()->caller; }
 
 //===----------------------------------------------------------------------===//
 // FileLineColLoc
 //===----------------------------------------------------------------------===//
 
 Location FileLineColLoc::get(Identifier filename, unsigned line,
-                             unsigned column, MLIRContext *context) {
-  return Base::get(context, filename, line, column);
+                             unsigned column) {
+  return Base::get(filename.getContext(), filename, line, column);
 }
 
 Location FileLineColLoc::get(StringRef filename, unsigned line, unsigned column,
                              MLIRContext *context) {
   return get(Identifier::get(filename.empty() ? "-" : filename, context), line,
-             column, context);
+             column);
 }
 
 StringRef FileLineColLoc::getFilename() const { return getImpl()->filename; }
 unsigned FileLineColLoc::getLine() const { return getImpl()->line; }
 unsigned FileLineColLoc::getColumn() const { return getImpl()->column; }
 
 //===----------------------------------------------------------------------===//
 // FusedLoc

 //===----------------------------------------------------------------------===//
 
 Location NameLoc::get(Identifier name, Location child) {
   assert(!child.isa<NameLoc>() &&
          "a NameLoc cannot be used as a child of another NameLoc");
   return Base::get(child->getContext(), name, child);
 }
 
-Location NameLoc::get(Identifier name, MLIRContext *context) {
-  return get(name, UnknownLoc::get(context));
+Location NameLoc::get(Identifier name) {
+  return get(name, UnknownLoc::get(name.getContext()));
 }
 
 /// Return the name identifier.
 Identifier NameLoc::getName() const { return getImpl()->name; }
 
 /// Return the child location.
 Location NameLoc::getChildLoc() const { return getImpl()->child; }
 

mlir/lib/IR/MLIRContext.cpp

if (impl.multiThreadedExecutionContext != 0)
           "missing `dependentDialects` in a pass for example.");
 #endif
     dialect = ctor();
     assert(dialect && "dialect ctor failed");
 
     // Refresh all the identifiers dialect field, this catches cases where a
     // dialect may be loaded after identifier prefixed with this dialect name
     // were already created.
+    llvm::SmallString<32> dialectPrefix(dialectNamespace);
+    dialectPrefix.push_back('.');
     for (auto &identifierEntry : impl.identifiers)
-      if (!identifierEntry.second &&
-          identifierEntry.first().startswith(dialectNamespace))
+      if (identifierEntry.second.is<MLIRContext *>() &&
+          identifierEntry.first().startswith(dialectPrefix))
         identifierEntry.second = dialect.get();
 
     // Actually register the interfaces with delayed registration.
     impl.dialectsRegistry.registerDelayedInterfaces(dialect.get());
     return dialect.get();
   }
 
   // Abort if dialect with namespace has already been registered.

mlir/lib/IR/Operation.cpp

 OperationName::OperationName(StringRef name, MLIRContext *context) {
   if (auto *op = AbstractOperation::lookup(name, context))
     representation = op;
   else
     representation = Identifier::get(name, context);
 }
 
 /// Return the name of the dialect this operation is registered to.
-StringRef OperationName::getDialect() const {
-  return getStringRef().split('.').first;
+StringRef OperationName::getDialectNamespace() const {
+  if (Dialect *dialect = getDialect())
+    return dialect->getNamespace();
+  return representation.get<Identifier>().strref().split('.').first;
 }
 
 /// Return the operation name with dialect name stripped, if it has one.
 StringRef OperationName::stripDialect() const {
   auto splitName = getStringRef().split(".");
   return splitName.second.empty() ? splitName.first : splitName.second;
 }
 
void Operation::destroy() {
   free(rawMem);
 }
 
 /// Return the context this operation is associated with.
 MLIRContext *Operation::getContext() { return location->getContext(); }
 
 /// Return the dialect this operation is associated with, or nullptr if the
 /// associated dialect is not registered.
-Dialect *Operation::getDialect() {
-  if (auto *abstractOp = getAbstractOperation())
-    return &abstractOp->dialect;
-
-  // If this operation hasn't been registered or doesn't have abstract
-  // operation, try looking up the dialect name in the context.
-  return getContext()->getLoadedDialect(getName().getDialect());
-}
+Dialect *Operation::getDialect() { return getName().getDialect(); }
 
 Region *Operation::getParentRegion() {
   return block ? block->getParent() : nullptr;
 }
 
 Operation *Operation::getParentOp() {
   return block ? block->getParentOp() : nullptr;
 }

mlir/lib/IR/Verifier.cpp

 /// This class encapsulates all the state used to verify an operation region.
 class OperationVerifier {
 public:
   explicit OperationVerifier(MLIRContext *ctx) : ctx(ctx) {}
 
   /// Verify the given operation.
   LogicalResult verify(Operation &op);
 
-  /// Returns the registered dialect for a dialect-specific attribute.
-  Dialect *getDialectForAttribute(const NamedAttribute &attr) {
-    assert(attr.first.strref().contains('.') && "expected dialect attribute");
-    auto dialectNamePair = attr.first.strref().split('.');
-    return ctx->getLoadedDialect(dialectNamePair.first);
-  }
-
 private:
   /// Verify the given potentially nested region or block.
   LogicalResult verifyRegion(Region &region);
   LogicalResult verifyBlock(Block &block);
   LogicalResult verifyOperation(Operation &op);
 
   /// Verify the dominance property of operations within the given Region.
   LogicalResult verifyDominance(Region &region);
InFlightDiagnostic emitError(Block &bb, const Twine &message) {
     return mlir::emitError(bb.getParent()->getLoc(), message);
   }
 
   /// The current context for the verifier.
   MLIRContext *ctx;
 
   /// Dominance information for this operation, when checking dominance.
   DominanceInfo *domInfo = nullptr;
-
-  /// Mapping between dialect namespace and if that dialect supports
-  /// unregistered operations.
-  llvm::StringMap<bool> dialectAllowsUnknownOps;
 };
 } // end anonymous namespace
 
 /// Verify the given operation.
 LogicalResult OperationVerifier::verify(Operation &op) {
   // Verify the operation first.
   if (failed(verifyOperation(op)))
     return failure();
LogicalResult OperationVerifier::verifyOperation(Operation &op) {
   // Check that operands are non-nil and structurally ok.
   for (auto operand : op.getOperands())
     if (!operand)
       return op.emitError("null operand found");
 
   /// Verify that all of the attributes are okay.
   for (auto attr : op.getAttrs()) {
     // Check for any optional dialect specific attributes.
-    if (!attr.first.strref().contains('.'))
-      continue;
-    if (auto *dialect = getDialectForAttribute(attr))
+    if (auto *dialect = attr.first.getDialect())
       if (failed(dialect->verifyOperationAttribute(&op, attr)))
         return failure();
   }
 
   // If we can get operation info for this, check the custom hook.
-  auto *opInfo = op.getAbstractOperation();
+  OperationName opName = op.getName();
+  auto *opInfo = opName.getAbstractOperation();
   if (opInfo && failed(opInfo->verifyInvariants(&op)))
     return failure();
 
   auto kindInterface = dyn_cast<mlir::RegionKindInterface>(op);
 
   // Verify that all child regions are ok.
   unsigned numRegions = op.getNumRegions();
   for (unsigned i = 0; i < numRegions; i++) {
if (failed(verifyRegion(region)))
       return failure();
   }
 
   // If this is a registered operation, there is nothing left to do.
   if (opInfo)
     return success();
 
   // Otherwise, verify that the parent dialect allows un-registered operations.
-  auto dialectPrefix = op.getName().getDialect();
-
-  // Check for an existing answer for the operation dialect.
-  auto it = dialectAllowsUnknownOps.find(dialectPrefix);
-  if (it == dialectAllowsUnknownOps.end()) {
-    // If the operation dialect is registered, query it directly.
-    if (auto *dialect = ctx->getLoadedDialect(dialectPrefix))
-      it = dialectAllowsUnknownOps
-               .try_emplace(dialectPrefix, dialect->allowsUnknownOperations())
-               .first;
-    // Otherwise, unregistered dialects (when allowed by the context)
-    // conservatively allow unknown operations.
-    else {
-      if (!op.getContext()->allowsUnregisteredDialects() && !op.getDialect())
-        return op.emitOpError()
-               << "created with unregistered dialect. If this is "
-                  "intended, please call allowUnregisteredDialects() on the "
-                  "MLIRContext, or use -allow-unregistered-dialect with "
-                  "mlir-opt";
-
-      it = dialectAllowsUnknownOps.try_emplace(dialectPrefix, true).first;
+  Dialect *dialect = opName.getDialect();
+  if (!dialect) {
+    if (!ctx->allowsUnregisteredDialects()) {
     }
+    return success();
   }
 
-  if (!it->second) {
+  if (!dialect->allowsUnknownOperations()) {
     return op.emitError("unregistered operation '")
-           << op.getName() << "' found in dialect ('" << dialectPrefix
+           << op.getName() << "' found in dialect ('" << dialect->getNamespace()
            << "') that does not allow unknown operations";
   }
 
   return success();
 }
 
 /// Attach a note to an in-flight diagnostic that provide more information about
 /// where an op operand is defined.

mlir/lib/Parser/DialectSymbolParser.cpp

return parseExtendedSymbol<Type>(
               symbolData, state.context, state.symbols, [&](Parser &parser) {
                 CustomDialectAsmParser customParser(symbolData, parser);
                 return dialect->parseType(customParser);
               });
         }
 
         // Otherwise, form a new opaque type.
         return OpaqueType::getChecked(
-            getEncodedSourceLocation(loc), state.context,
+            getEncodedSourceLocation(loc),
             Identifier::get(dialectName, state.context), symbolData);
       });
 }
 
 //===----------------------------------------------------------------------===//
 // mlir::parseAttribute/parseType
 //===----------------------------------------------------------------------===//
 

mlir/lib/Parser/LocationParser.cpp

if (childLoc.isa<NameLoc>())
                        "child of NameLoc cannot be another NameLoc");
     loc = NameLoc::get(Identifier::get(str, ctx), childLoc);
 
     // Parse the closing ')'.
     if (parseToken(Token::r_paren,
                    "expected ')' after child location of NameLoc"))
       return failure();
   } else {
-    loc = NameLoc::get(Identifier::get(str, ctx), ctx);
+    loc = NameLoc::get(Identifier::get(str, ctx));
   }
 
   return success();
 }
 
 ParseResult Parser::parseLocationInstance(LocationAttr &loc) {
   // Handle either name or filelinecol locations.
   if (getToken().is(Token::string))

mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp

 
 Location spirv::Deserializer::createFileLineColLoc(OpBuilder opBuilder) {
   if (!debugLine)
     return unknownLoc;
 
   auto fileName = debugInfoMap.lookup(debugLine->fileID).str();
   if (fileName.empty())
     fileName = "<unknown>";
-  return opBuilder.getFileLineColLoc(opBuilder.getIdentifier(fileName),
-                                     debugLine->line, debugLine->col);
+  return FileLineColLoc::get(opBuilder.getIdentifier(fileName), debugLine->line,
+                             debugLine->col);
 }
 
 LogicalResult
 spirv::Deserializer::processDebugLine(ArrayRef<uint32_t> operands) {
   // According to SPIR-V spec:
   // "This location information applies to the instructions physically
   // following this instruction, up to the first occurrence of any of the
   // following: the next end of block, the next OpLine instruction, or the next

mlir/lib/Transforms/LocationSnapshot.cpp

static void generateLocationsFromIR(raw_ostream &os, StringRef fileName,
   op->walk([&](Operation *opIt) {
     // Check to see if this operation has a mapped location. Some operations may
     // be elided from the printed form, e.g. the body terminators of some region
     // operations.
     auto it = opToLineCol.find(opIt);
     if (it == opToLineCol.end())
       return;
     const std::pair<unsigned, unsigned> &lineCol = it->second;
-    auto newLoc =
-        builder.getFileLineColLoc(file, lineCol.first, lineCol.second);
+    auto newLoc = FileLineColLoc::get(file, lineCol.first, lineCol.second);
 
     // If we don't have a tag, set the location directly
     if (!tagIdentifier) {
       opIt->setLoc(newLoc);
       return;
     }
 
     // Otherwise, build a fused location with the existing op loc.

mlir/lib/Transforms/Utils/DialectConversion.cpp

 /// Get the legalization information for the given operation.
 auto ConversionTarget::getOpInfo(OperationName op) const
     -> Optional<LegalizationInfo> {
   // Check for info for this specific operation.
   auto it = legalOperations.find(op);
   if (it != legalOperations.end())
     return it->second;
   // Check for info for the parent dialect.
-  auto dialectIt = legalDialects.find(op.getDialect());
+  auto dialectIt = legalDialects.find(op.getDialectNamespace());
   if (dialectIt != legalDialects.end()) {
     Optional<DynamicLegalityCallbackFn> callback;
-    auto dialectFn = dialectLegalityFns.find(op.getDialect());
+    auto dialectFn = dialectLegalityFns.find(op.getDialectNamespace());
     if (dialectFn != dialectLegalityFns.end())
       callback = dialectFn->second;
     return LegalizationInfo{dialectIt->second, /*isRecursivelyLegal=*/false,
                             callback};
   }
   // Otherwise, check if we mark unknown operations as dynamic.
   if (unknownOpsDynamicallyLegal)
     return LegalizationInfo{LegalizationAction::Dynamic,

mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-yaml-gen.cpp

int main(int argc, char **argv) {
   for (auto &opConfig : opConfigs) {
     if (!opConfig.metadata) {
       emitError(genContext.getLoc())
           << "missing operation metadata on subsequent op";
       return 1;
     }
 
     genContext.setLoc(NameLoc::get(
-        Identifier::get(opConfig.metadata->cppOpName, &mlirContext),
-        &mlirContext));
+        Identifier::get(opConfig.metadata->cppOpName, &mlirContext)));
     if (failed(generateOp(opConfig, genContext))) {
       return 1;
     }
   }
 
   if (outputOdsDecl)
     outputOdsDecl->keep();
   if (outputCppImpl)
     outputCppImpl->keep();
 
   return 0;
 }

mlir/tools/mlir-tblgen/RewriterGen.cpp

llvm::PrintFatalError(
         "At least one argument to location directive required");
 
   if (!tree.getSymbol().empty())
     PrintFatalError(loc, "cannot bind symbol to location");
 
   if (tree.getNumArgs() == 1) {
     DagLeaf leaf = tree.getArgAsLeaf(0);
     if (leaf.isStringAttr())
-      return formatv("::mlir::NameLoc::get(rewriter.getIdentifier(\"{0}\"), "
-                     "rewriter.getContext())",
+      return formatv("::mlir::NameLoc::get(rewriter.getIdentifier(\"{0}\"))",
                      leaf.getStringAttr())
           .str();
     return lookUpArgLoc(0);
   }
 
   std::string ret;
   llvm::raw_string_ostream os(ret);
   std::string strAttr;

mlir/unittests/IR/AttributeTest.cpp

TEST(DenseSplatTest, BF16Splat) {
   Attribute value = FloatAttr::get(floatTy, 10.0);
 
   testSplat(floatTy, value);
 }
 
 TEST(DenseSplatTest, StringSplat) {
   MLIRContext context;
   Type stringType =
-      OpaqueType::get(&context, Identifier::get("test", &context), "string");
+      OpaqueType::get(Identifier::get("test", &context), "string");
   StringRef value = "test-string";
   testSplat(stringType, value);
 }
 
 TEST(DenseSplatTest, StringAttrSplat) {
   MLIRContext context;
   Type stringType =
-      OpaqueType::get(&context, Identifier::get("test", &context), "string");
+      OpaqueType::get(Identifier::get("test", &context), "string");
   Attribute stringAttr = StringAttr::get("test-string", stringType);
   testSplat(stringType, stringAttr);
 }
 
 TEST(DenseComplexTest, ComplexFloatSplat) {
   MLIRContext context;
   ComplexType complexType = ComplexType::get(FloatType::getF32(&context));
   std::complex<float> value(10.0, 15.0);