[mlir] Add a new builtin DenseResourceElementsAttr

[rriddle]

Summary

This attributes is intended cover the current set of use cases that abuse
DenseElementsAttr, e.g. when the data is large. Using resources for large
data is one of the major reasons why they were added; e.g. they can be
deallocated mid-compilation, they support a wide variety of data origins
(e.g, heap allocated, mmap'd, etc.), they can support mutation, etc.

I considered at length not having a builtin variant of this, and instead
having multiple versions of this attribute for dialects that are interested,
but they all boiled down to the exact same attribute definition. Given the
generality of this attribute, it feels more aligned to keep it next to DenseArrayAttr
(given that DenseArrayAttr covers the "small" case, and DenseResourcesElementsAttr
covers the "large" case). The underlying infra used to build this attribute is
general, and having a builtin attribute doesn't preclude users from defining
their own when it makes sense (they can even share a blob manager with the
builtin dialect to avoid data duplication).

[rriddle]

I haven't added tests yet, uploaded early to link from OpaqueElementsAttr removal (https://reviews.llvm.org/D129917).

[mehdi_amini]

I'm not convinced by this right now: it seems to me that this has a lot of the short-comings that DenseElementsAttr has, in particular the verification logic has to be externalized in the ops using it. This seems fine on the surface (invariants are enforced, it's not the "JSON of IR") until you start writing C++ using this API: everywhere a DenseElementAttr is passed the verification context is loose and makes the code harder to understand and maintain.
This is why DenseArrayAttr was added with explicit definitions of all the variants: to provide a "closed" API (when you get a DenseIt64ArrayAttr you're manipulating an ArrayRef<int64_t> and it is reflected in the API usage without any cast at the use site).

What I'd like to see here is that we define op so that the C++ class returned in the API is "type safe": it has a C++ API / accessors that matches the constraints of the verifier.

[rriddle]

In D130022#3660662, @mehdi_amini wrote:

I'm not convinced by this right now: it seems to me that this has a lot of the short-comings that DenseElementsAttr has, in particular the verification logic has to be externalized in the ops using it. This seems fine on the surface (invariants are enforced, it's not the "JSON of IR") until you start writing C++ using this API: everywhere a DenseElementAttr is passed the verification context is loose and makes the code harder to understand and maintain.
This is why DenseArrayAttr was added with explicit definitions of all the variants: to provide a "closed" API (when you get a DenseIt64ArrayAttr you're manipulating an ArrayRef<int64_t> and it is reflected in the API usage without any cast at the use site).

What I'd like to see here is that we define op so that the C++ class returned in the API is "type safe": it has a C++ API / accessors that matches the constraints of the verifier.

The patch isn't done as-is, I uploaded early to give some context to the OpaqueElementsAttr patch. Realistically, the part that isn't done in this patch so far is the user facing API. The intention, from my perspective, is to have this be a sibling in some ways to DenseArrayAttr (with the inevitable goal of killing DenseElementsAttr in favor of a combination of these two). I'm fine with modeling the API in a similar way to DenseArrayAttr if you prefer.

One problem long-term though with killing DenseElementsAttr, is what to do about non-native types that we still want to model arrays for (e.g. i4, etc.)

[mehdi_amini]

(I missed the fact that this was sent in connection with the other review)

For i4: I'm not saying that we should provide an ArrayRef API everywhere: iterator and ranges are fine as needed.
The part I'm pointing at the discrepancy between the C++ API and the verifier/ODS invariants.
So if we have a DenseI4ResourceElementsAttr n array of i4, how would we implement it by hand in C++? What would the "perfect" API look like?
It may something like operator[] returns a int32 accessing a given element of the array and masking/shifting it. But a DenseF64ResourceElementsAttr would have the same API returning a double.

[rriddle]

In D130022#3660801, @mehdi_amini wrote:

(I missed the fact that this was sent in connection with the other review)

For i4: I'm not saying that we should provide an ArrayRef API everywhere: iterator and ranges are fine as needed.
The part I'm pointing at the discrepancy between the C++ API and the verifier/ODS invariants.
So if we have a DenseI4ResourceElementsAttr n array of i4, how would we implement it by hand in C++? What would the "perfect" API look like?
It may something like operator[] returns a int32 accessing a given element of the array and masking/shifting it. But a DenseF64ResourceElementsAttr would have the same API returning a double.

Right, right. I agree there. I think that as part of evolving the ElementsAttr APIs, I think moving to having concrete sub-classes represent distinct use cases makes sense. It's much more maintainable than just assuming something you can iterate i32 because it has an i32 element type. The concentration of all APIs on DenseElementsAttr is a historical thing at this point. I think we could have things like e.g., APIntElementsAttr that explicitly know and provide accessors for APInt. From my perspective, I think a good path forward really would be:

DenseArrayAttr -> Used for "small" data that gets allocated in the context
DenseResourceElementsAttr -> Used for "large", generally external

On top of that though, we have the selective classes for known data types (i.e. how DenseArrayAttr has multiple classes that expose controlled APIs). We can also do this for ElementsAttr in general, i.e. have classes that inherit from ElementsAttr but have guarantees on iteration (e.g. the APIntElementsAttr example above). The main thing I think we should reach for here is having a cohesive API between the attributes.

[jpienaar]

Looks good, primary question about builtin dialect here & if the changes to API addressed Mehdi's concerns (I think it does)

mlir/include/mlir/IR/BuiltinAttributes.td

441

ElementsAttr ?

442

Is there any instance where this isn't actually a DenseElementsAttr ? (ElementsAttr is more general and could be used in more spots, so this is more OOC and as densely here triggers that)

468

inserts where?

477

Is public: needed here?

mlir/lib/AsmParser/AttributeParser.cpp

945 ↗

(On Diff #447534)

Is builtin used only as we need some spot to stick it?

mlir/lib/AsmParser/Parser.cpp

345 ↗

(On Diff #447534)

dyn_cast_if_present ? Also when would dialect be null here? (the error below would segfault in that case I believe)

mlir/test/IR/invalid-file-metadata.mlir

65 ↗

(On Diff #447534)

Use shape dialect? (I could see ml_program and TOSA getting support ~soon, while I don't imagine a shape that large that we'd want it as a resource, arith would be another option)

[mehdi_amini]

Looks good overall, but I'd like to see positive tests (not only "invalid") and more coverage for the added APIs.

mlir/include/mlir/IR/BuiltinAttributes.td

447

I think these are copy/pasted and not updated.

[rriddle]

mlir/include/mlir/IR/BuiltinAttributes.td

441

This is how we spell it in the rest of the docs, so I wanted to be consistent there.

442

I don't think there's a supported case right now where this isn't dense, otherwise it'd be difficult to reason about this generically (you can't reason about the data generically at all). If we wanted to expand beyond that, we'd need to understand the use case better IMO.

477

Yeah, given that other stuff may be emitted after this section (AFAIK we don't always emit the extraDecls section last).

mlir/lib/AsmParser/AttributeParser.cpp

945 ↗

(On Diff #447534)

To some extent, the builtin dialect manages all of the resources referenced by DenseResourceElementsAttr. This is statically guaranteed by the DenseResourceElementsHandle, which is a handle only for the builtin dialect.

[mehdi_amini]

mlir/test/IR/dense-resource-elements-attr.mlir

1 ↗

(On Diff #448420)

Why this -allow-unregistered-dialect ?

mlir/include/mlir/IR/BuiltinAttributes.h

 #include "mlir/IR/BuiltinAttributeInterfaces.h"
 #include "mlir/IR/SubElementInterfaces.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/Sequence.h"
 #include <complex>
 
 namespace mlir {
 class AffineMap;
+class AsmResourceBlob;
 class BoolAttr;
+class BuiltinDialect;
 class DenseIntElementsAttr;
+template <typename T>
+struct DialectResourceBlobHandle;
 class FlatSymbolRefAttr;
 class FunctionType;
 class IntegerSet;
 class IntegerType;
 class Location;
 class Operation;
 class ShapedType;
 
public:
   using DenseElementsAttr::DenseElementsAttr;
 
   /// Method for support type inquiry through isa, cast and dyn_cast.
   static bool classof(Attribute attr) {
     auto denseAttr = attr.dyn_cast<DenseElementsAttr>();
     return denseAttr && denseAttr.isSplat();
   }
 };
+
+//===----------------------------------------------------------------------===//
+// DenseResourceElementsAttr
+//===----------------------------------------------------------------------===//
+
+using DenseResourceElementsHandle = DialectResourceBlobHandle<BuiltinDialect>;
+
 } // namespace mlir
 
 //===----------------------------------------------------------------------===//
 // Tablegen Attribute Declarations
 //===----------------------------------------------------------------------===//
 
 #define GET_ATTRDEF_CLASSES
 #include "mlir/IR/BuiltinAttributes.h.inc"

mlir/include/mlir/IR/BuiltinAttributes.td

 //===----------------------------------------------------------------------===//
 
 #ifndef BUILTIN_ATTRIBUTES
 #define BUILTIN_ATTRIBUTES
 
 include "mlir/IR/AttrTypeBase.td"
 include "mlir/IR/BuiltinDialect.td"
 include "mlir/IR/BuiltinAttributeInterfaces.td"
+include "mlir/IR/OpAsmInterface.td"
 include "mlir/IR/SubElementInterfaces.td"
 
 // TODO: Currently the attributes defined in this file are prefixed with
 // `Builtin_`.  This is to differentiate the attributes here with the ones in
 // OpBase.td. We should remove the definitions in OpBase.td, and repoint users
 // to this file instead.
 
 // Base class for Builtin dialect attributes.
def Builtin_DenseStringElementsAttr : Builtin_Attr<
   public:
   }];
   let genAccessors = 0;
   let genStorageClass = 0;
   let skipDefaultBuilders = 1;
 }
 
 //===----------------------------------------------------------------------===//
+// DenseResourceElementsAttr
+//===----------------------------------------------------------------------===//
+
+def Builtin_DenseResourceElementsAttr : Builtin_Attr<"DenseResourceElements", [
+    ElementsAttrInterface
+  ]> {
+  let summary = "An Attribute containing a dense multi-dimensional array "
+                "backed by a resource";
+  let description = [{
+    Syntax:
+
+    ```
+    dense-resource-elements-attribute ::=
+      `dense_resource` `<` resource-handle `>` `:` shaped-type
+    ```
+
+    A dense resource elements attribute is an elements attribute backed by a
+    handle to a builtin dialect resource containing a densely packed array of
+    values. There are no restrictions placed on the shaped type or element
+    type of this attribute.
+
+    Examples:
+
+    ```mlir
+    // A tensor referencing a builtin dialect resource, `resource_1`, with two
+    // unsigned i32 elements.
+    dense_resource<resource_1> : tensor<2xui32>
+    ```
+  }];
+  let parameters = (ins
+    AttributeSelfTypeParameter<"", "ShapedType">:$type,
+    ResourceHandleParameter<"DenseResourceElementsHandle">:$handle
+  );
+  let builders = [
+    // A builder that inserts a new resource using the provided blob. The handle
+    // of the inserted blob is used when building the attribute. The provided
+    // `blobName` is used as a hint for the key of the new handle for the
+    // `blob` resource, but may be changed if necessary to ensure uniqueness
+    // during insertion.
+    AttrBuilderWithInferredContext<(ins
+      "ShapedType":$type, "DenseResourceElementsHandle":$handle
+    )>,
+    // A builder that inserts a new resource using the provided blob. The handle
+    // of the inserted blob is used when building the attribute. The provided
+    // `blobName` is used as a hint for the key of the new handle for the
+    // `blob` resource, but may be changed if necessary to ensure uniqueness
+    // during insertion.
+    AttrBuilderWithInferredContext<(ins
+      "ShapedType":$type, "StringRef":$blobName, "AsmResourceBlob":$blob
+    )>,
+    // A builder that inserts a new resource using the provided blob. The handle
+    // of the inserted blob is used when building the attribute.
+    AttrBuilderWithInferredContext<(ins
+      "ShapedType":$type, "AsmResourceBlob":$blob
+    )>,
+  ];
+}
+
+//===----------------------------------------------------------------------===//
 // DictionaryAttr
 //===----------------------------------------------------------------------===//
 
 def Builtin_DictionaryAttr : Builtin_Attr<"Dictionary", [
     DeclareAttrInterfaceMethods<SubElementAttrInterface,
         ["replaceImmediateSubAttribute"]>
   ]> {
   let summary = "An dictionary of named Attribute values";

mlir/lib/IR/AsmPrinter.cpp

 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/AsmState.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinDialect.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/DialectImplementation.h"
+#include "mlir/IR/DialectResourceBlobManager.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/SubElementInterfaces.h"
 #include "mlir/IR/Verifier.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/DenseMap.h"
if (!isa<BuiltinDialect>(attr.getDialect())) {
     case DenseArrayBaseAttr::EltType::F64:
       os << "[:f64";
       break;
     }
     if (denseArrayAttr.getType().cast<ShapedType>().getRank())
       os << " ";
     denseArrayAttr.printWithoutBraces(os);
     os << "]";
+  } else if (auto resourceAttr = attr.dyn_cast<DenseResourceElementsAttr>()) {
+    os << "dense_resource<";
+    printResourceHandle(resourceAttr.getHandle());
+    os << ">";
   } else if (auto locAttr = attr.dyn_cast<LocationAttr>()) {
     printLocation(locAttr);
   } else {
     llvm::report_fatal_error("Unknown builtin attribute");
   }
   // Don't print the type if we must elide it, or if it is a None type.
   if (typeElision != AttrTypeElision::Must && !attrType.isa<NoneType>()) {
     os << " : ";

mlir/lib/IR/BuiltinAttributes.cpp

 //===- BuiltinAttributes.cpp - MLIR Builtin Attribute Classes -------------===//
 //
 // 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/IR/BuiltinAttributes.h"
 #include "AttributeDetail.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/BuiltinDialect.h"
 #include "mlir/IR/Dialect.h"
+#include "mlir/IR/DialectResourceBlobManager.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Interfaces/DecodeAttributesInterfaces.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/Sequence.h"

 
 /// Method for supporting type inquiry through isa, cast and dyn_cast.
 bool DenseIntElementsAttr::classof(Attribute attr) {
   return attr.isa<DenseElementsAttr>() &&
          attr.getType().cast<ShapedType>().getElementType().isIntOrIndex();
 }
 
 //===----------------------------------------------------------------------===//
+// DenseResourceElementsAttr
+//===----------------------------------------------------------------------===//
+
+DenseResourceElementsAttr
+DenseResourceElementsAttr::get(ShapedType type,
+                               DenseResourceElementsHandle handle) {
+  return Base::get(type.getContext(), type, handle);
+}
+
+DenseResourceElementsAttr DenseResourceElementsAttr::get(ShapedType type,
+                                                         StringRef blobName,
+                                                         AsmResourceBlob blob) {
+  // Extract the builtin dialect resource manager from context.
+  MLIRContext *context = type.getContext();
+  BuiltinDialect *dialect = context->getLoadedDialect<BuiltinDialect>();
+  auto *interface = dialect->getRegisteredInterface<
+      ResourceBlobManagerDialectInterfaceBase<DenseResourceElementsHandle>>();
+
+  // Construct a handle by inserting a new resource using the provided blob.
+  return get(context, type, interface->insert(blobName, std::move(blob)));
+}
+
+DenseResourceElementsAttr DenseResourceElementsAttr::get(ShapedType type,
+                                                         AsmResourceBlob blob) {
+  // If we don't care about the resource name, just use a sensible default.
+  return get(type, "resource", std::move(blob));
+}
+
+//===----------------------------------------------------------------------===//
 // OpaqueElementsAttr
 //===----------------------------------------------------------------------===//
 
 bool OpaqueElementsAttr::decode(ElementsAttr &result) {
   Dialect *dialect = getContext()->getLoadedDialect(getDialect());
   if (!dialect)
     return true;
   auto *interface = llvm::dyn_cast<DialectDecodeAttributesInterface>(dialect);

mlir/lib/IR/BuiltinDialect.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/BuiltinDialect.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
+#include "mlir/IR/DialectResourceBlobManager.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/PatternMatch.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
-// Builtin Dialect
+// TableGen'erated dialect
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/BuiltinDialect.cpp.inc"
 
+//===----------------------------------------------------------------------===//
+// BuiltinBlobManagerInterface
+//===----------------------------------------------------------------------===//
+
+using BuiltinBlobManagerInterface =
+    ResourceBlobManagerDialectInterfaceBase<DenseResourceElementsHandle>;
+
+//===----------------------------------------------------------------------===//
+// BuiltinOpAsmDialectInterface
+//===----------------------------------------------------------------------===//
+
 namespace {
 struct BuiltinOpAsmDialectInterface : public OpAsmDialectInterface {
-  using OpAsmDialectInterface::OpAsmDialectInterface;
+  BuiltinOpAsmDialectInterface(Dialect *dialect,
+                               BuiltinBlobManagerInterface &mgr)
+      : OpAsmDialectInterface(dialect), blobManager(mgr) {}
 
   AliasResult getAlias(Attribute attr, raw_ostream &os) const override {
     if (attr.isa<AffineMapAttr>()) {
       os << "map";
       return AliasResult::OverridableAlias;
     }
     if (attr.isa<IntegerSetAttr>()) {
       os << "set";
AliasResult getAlias(Type type, raw_ostream &os) const final {
     if (auto tupleType = type.dyn_cast<TupleType>()) {
       if (tupleType.size() > 16) {
         os << "tuple";
         return AliasResult::OverridableAlias;
       }
     }
     return AliasResult::NoAlias;
   }
+
+  //===------------------------------------------------------------------===//
+  // Resources
+  //===------------------------------------------------------------------===//
+
+  std::string
+  getResourceKey(const AsmDialectResourceHandle &handle) const override {
+    return cast<DenseResourceElementsHandle>(handle).getKey().str();
+  }
+  FailureOr<AsmDialectResourceHandle>
+  declareResource(StringRef key) const final {
+    return blobManager.insert(key);
+  }
+  LogicalResult parseResource(AsmParsedResourceEntry &entry) const final {
+    FailureOr<AsmResourceBlob> blob = entry.parseAsBlob();
+    if (failed(blob))
+      return failure();
+
+    // Update the blob for this entry.
+    blobManager.update(entry.getKey(), std::move(*blob));
+    return success();
+  }
+  void
+  buildResources(Operation *op,
+                 const SetVector<AsmDialectResourceHandle> &referencedResources,
+                 AsmResourceBuilder &provider) const final {
+    blobManager.buildResources(provider, referencedResources.getArrayRef());
+  }
+
+private:
+  /// The blob manager for the dialect.
+  BuiltinBlobManagerInterface &blobManager;
 };
 } // namespace
 
 void BuiltinDialect::initialize() {
   registerTypes();
   registerAttributes();
   registerLocationAttributes();
   addOperations<
 #define GET_OP_LIST
 #include "mlir/IR/BuiltinOps.cpp.inc"
       >();
-  addInterfaces<BuiltinOpAsmDialectInterface>();
+
+  auto &blobInterface = addInterface<BuiltinBlobManagerInterface>();
+  addInterface<BuiltinOpAsmDialectInterface>(blobInterface);
 }
 
 //===----------------------------------------------------------------------===//
 // ModuleOp
 //===----------------------------------------------------------------------===//
 
 void ModuleOp::build(OpBuilder &builder, OperationState &state,
                      Optional<StringRef> name) {

mlir/lib/Parser/AttributeParser.cpp

 //===- AttributeParser.cpp - MLIR Attribute Parser Implementation ---------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the parser for the MLIR Types.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Parser.h"
 
 #include "AsmParserImpl.h"
 #include "mlir/IR/AffineMap.h"
+#include "mlir/IR/BuiltinDialect.h"
 #include "mlir/IR/BuiltinTypes.h"
-#include "mlir/IR/Dialect.h"
 #include "mlir/IR/DialectImplementation.h"
+#include "mlir/IR/DialectResourceBlobManager.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/Parser/AsmParserState.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/Endian.h"
 
 using namespace mlir;
 using namespace mlir::detail;
 
Attribute Parser::parseAttribute(Type type) {
   case Token::kw_true:
     consumeToken(Token::kw_true);
     return builder.getBoolAttr(true);
 
   // Parse a dense elements attribute.
   case Token::kw_dense:
     return parseDenseElementsAttr(type);
 
+  // Parse a dense resource elements attribute.
+  case Token::kw_dense_resource:
+    return parseDenseResourceElementsAttr(type);
+
   // Parse a dictionary attribute.
   case Token::l_brace: {
     NamedAttrList elements;
     if (parseAttributeDict(elements))
       return nullptr;
     return elements.getDictionary(getContext());
   }
 
Attribute Parser::parseDenseElementsAttr(Type attrType) {
   // case.
   auto loc = attrType ? attribLoc : getToken().getLoc();
   auto type = parseElementsLiteralType(attrType);
   if (!type)
     return nullptr;
   return literalParser.getAttr(loc, type);
 }
 
+Attribute Parser::parseDenseResourceElementsAttr(Type attrType) {
+  auto loc = getToken().getLoc();
+  consumeToken(Token::kw_dense_resource);
+  if (parseToken(Token::less, "expected '<' after 'dense_resource'"))
+    return nullptr;
+
+  // Parse the resource handle.
+  FailureOr<AsmDialectResourceHandle> rawHandle =
+      parseResourceHandle(getContext()->getLoadedDialect<BuiltinDialect>());
+  if (failed(rawHandle) || parseToken(Token::greater, "expected '>'"))
+    return nullptr;
+
+  auto *handle = dyn_cast<DenseResourceElementsHandle>(&*rawHandle);
+  if (!handle)
+    return emitError(loc, "invalid `dense_resource` handle type"), nullptr;
+
+  // Parse the type of the attribute if the user didn't provide one.
+  SMLoc typeLoc = loc;
+  if (!attrType) {
+    typeLoc = getToken().getLoc();
+    if (parseToken(Token::colon, "expected ':'") || !(attrType = parseType()))
+      return nullptr;
+  }
+  ShapedType shapedType = attrType.dyn_cast<ShapedType>();
+  if (!shapedType) {
+    emitError(typeLoc, "`dense_resource` expected a shaped type");
+    return nullptr;
+  }
+
+  return DenseResourceElementsAttr::get(shapedType, *handle);
+}
+
 /// Parse an opaque elements attribute.
 Attribute Parser::parseOpaqueElementsAttr(Type attrType) {
   SMLoc loc = getToken().getLoc();
   consumeToken(Token::kw_opaque);
   if (parseToken(Token::less, "expected '<' after 'opaque'"))
     return nullptr;
 
   if (getToken().isNot(Token::string))

mlir/lib/Parser/Parser.h

public:
 
   //===--------------------------------------------------------------------===//
   // Resource Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse a handle to a dialect resource within the assembly format.
   FailureOr<AsmDialectResourceHandle>
   parseResourceHandle(const OpAsmDialectInterface *dialect, StringRef &name);
+  FailureOr<AsmDialectResourceHandle> parseResourceHandle(Dialect *dialect);
 
   //===--------------------------------------------------------------------===//
   // Type Parsing
   //===--------------------------------------------------------------------===//
 
   /// Invoke the `getChecked` method of the given Attribute or Type class, using
   /// the provided location to emit errors in the case of failure. Note that
   /// unlike `OpBuilder::getType`, this method does not implicitly insert a
public:
 
   /// Parse an opaque elements attribute.
   Attribute parseOpaqueElementsAttr(Type attrType);
 
   /// Parse a dense elements attribute.
   Attribute parseDenseElementsAttr(Type attrType);
   ShapedType parseElementsLiteralType(Type type);
 
+  /// Parse a dense resource elements attribute.
+  Attribute parseDenseResourceElementsAttr(Type attrType);
+
   /// Parse a DenseArrayAttr.
   Attribute parseDenseArrayAttr();
 
   /// Parse a sparse elements attribute.
   Attribute parseSparseElementsAttr(Type attrType);
 
   //===--------------------------------------------------------------------===//
   // Location Parsing

mlir/lib/Parser/Parser.cpp

if (entry.first.empty()) {
     entry.first = dialect->getResourceKey(*result);
     entry.second = *result;
   }
 
   name = entry.first;
   return entry.second;
 }
 
+FailureOr<AsmDialectResourceHandle>
+Parser::parseResourceHandle(Dialect *dialect) {
+  const auto *interface = dyn_cast_or_null<OpAsmDialectInterface>(dialect);
+  if (!interface) {
+    return emitError() << "dialect '" << dialect->getNamespace()
+                       << "' does not expect resource handles";
+  }
+  StringRef resourceName;
+  return parseResourceHandle(interface, resourceName);
+}
+
 //===----------------------------------------------------------------------===//
 // Code Completion
 
 ParseResult Parser::codeCompleteDialectName() {
   state.codeCompleteContext->completeDialectName();
   return failure();
 }
 

mlir/lib/Parser/TokenKinds.def

 // this list and to cater to OCD.
 TOK_KEYWORD(affine_map)
 TOK_KEYWORD(affine_set)
 TOK_KEYWORD(attributes)
 TOK_KEYWORD(bf16)
 TOK_KEYWORD(ceildiv)
 TOK_KEYWORD(complex)
 TOK_KEYWORD(dense)
+TOK_KEYWORD(dense_resource)
 TOK_KEYWORD(f16)
 TOK_KEYWORD(f32)
 TOK_KEYWORD(f64)
 TOK_KEYWORD(f80)
 TOK_KEYWORD(f128)
 TOK_KEYWORD(false)
 TOK_KEYWORD(floordiv)
 TOK_KEYWORD(for)

mlir/lib/Tools/mlir-lsp-server/MLIRServer.cpp

for (StringRef token : tokens) {
                                /*sortText=*/"0");
       item.detail = optional ? "optional" : "";
       completionList.items.emplace_back(item);
     }
   }
 
   /// Signal a completion for an attribute.
   void completeAttribute(const llvm::StringMap<Attribute> &aliases) override {
-    appendSimpleCompletions({"affine_set", "affine_map", "dense", "false",
-                             "loc", "opaque", "sparse", "true", "unit"},
+    appendSimpleCompletions({"affine_set", "affine_map", "dense",
+                             "dense_resource", "false", "loc", "opaque",
+                             "sparse", "true", "unit"},
                             lsp::CompletionItemKind::Field,
                             /*sortText=*/"1");
 
     completeDialectName("#");
     completeAliases(aliases, "#");
   }
   void completeDialectAttributeOrAlias(
       const llvm::StringMap<Attribute> &aliases) override {